WIP: Allow unit tests to link against executable targets, postprocessing their object files to elide _main. Currently works only on Darwin (it requires nmedit) but can be made to work on other platforms using strip. It would be better to have a linker flag to allow _main to be ignored from certain .o files. It's also not clear that we will want to allow any product to link against an executable target.

Author: abertelrud

Sources/Build/BuildPlan.swift

@@ -1001,7 +1001,7 @@ public final class ProductBuildDescription {
         return buildParameters.binaryPath(for: product)
     }
 
-    /// The objects in this product.
+    /// All object files to link into this product.
     ///
     // Computed during build planning.
     public fileprivate(set) var objects = SortedArray<AbsolutePath>()
@@ -1019,6 +1019,10 @@ public final class ProductBuildDescription {
     /// The list of Swift modules that should be passed to the linker. This is required for debugging to work.
     fileprivate var swiftASTs: SortedArray<AbsolutePath> = .init()
 
+    /// Ordered mapping of any mainless object files used by the product to the originals in the executable
+    /// targets that produce them.
+    public fileprivate(set) var executableObjects: OrderedDictionary<AbsolutePath, AbsolutePath> = .init()
+
     /// Paths to the binary libraries the product depends on.
     fileprivate var libraryBinaryPaths: Set<AbsolutePath> = []
 
@@ -1032,6 +1036,11 @@ public final class ProductBuildDescription {
         return tempsPath.appending(component: "Objects.LinkFileList")
     }
 
+    /// Path to the symbol removal list file (list of symbols to remove from any objects linked into this product).
+    var mainSymbolRemovalListFilePath: AbsolutePath {
+        return tempsPath.appending(component: "MainSymbol.SymbolList")
+    }
+
     /// Diagnostics Engine for emitting diagnostics.
     let diagnostics: DiagnosticsEngine
 
@@ -1189,6 +1198,16 @@ public final class ProductBuildDescription {
         try fs.writeFileContents(linkFileListPath, bytes: stream.bytes)
     }
 
+    /// Writes symbol removal list file to the filesystem.
+    func writeMainSymbolRemovalListFile(_ fs: FileSystem) throws {
+        let stream = BufferedOutputByteStream()
+        
+        stream <<< "_main\n"
+
+        try fs.createDirectory(mainSymbolRemovalListFilePath.parentDirectory, recursive: true)
+        try fs.writeFileContents(mainSymbolRemovalListFilePath, bytes: stream.bytes)
+    }
+
     /// Returns the build flags from the declared build settings.
     private func buildSettingsFlags() -> [String] {
         var flags: [String] = []
@@ -1480,14 +1499,14 @@ public class BuildPlan {
 
         // Link C++ if needed.
         // Note: This will come from build settings in future.
-        for target in dependencies.staticTargets {
+        for target in dependencies.staticTargets + dependencies.executableTargets {
             if case let target as ClangTarget = target.underlyingTarget, target.isCXX {
                 buildProduct.additionalFlags += self.buildParameters.toolchain.extraCPPFlags
                 break
             }
         }
 
-        for target in dependencies.staticTargets {
+        for target in dependencies.staticTargets + dependencies.executableTargets {
             switch target.underlyingTarget {
             case is SwiftTarget:
                 // Swift targets are guaranteed to have a corresponding Swift description.
@@ -1509,10 +1528,29 @@ public class BuildPlan {
             }
         }
 
-        buildProduct.staticTargets = dependencies.staticTargets
+        buildProduct.staticTargets = dependencies.staticTargets + dependencies.executableTargets
         buildProduct.dylibs = dependencies.dylibs.map({ productMap[$0]! })
         buildProduct.objects += dependencies.staticTargets.flatMap({ targetMap[$0]!.objects })
         buildProduct.libraryBinaryPaths = dependencies.libraryBinaryPaths
+        
+        // If we're linking against any executable targets, we need to create versions of the .o files from those
+        // targets that elide the `_main` symbol.  We should look into whether linker options can be added to specify
+        // this on the command line.
+        if !dependencies.executableTargets.isEmpty {
+            // Creating a mapping from each .o file in each executable target to a corresponding modified .o file in
+            // our product directory.  This duplicates work if an executable is tested by more than one test product
+            // but has the advantage of keeping the executable target clean unless it's being used by a test target.
+            for target in dependencies.executableTargets.map({ targetMap[$0]! }) {
+                for object in target.objects {
+                    // FIXME: Plenty of opportunity for collisions here — how is this handled for regular object files?
+                    let mainlessObject = buildProduct.tempsPath.appending(components: "LinkedExecutableObjects", "\(target.target.c99name)_\(object.basename)")
+                    buildProduct.executableObjects[mainlessObject] = object
+                    buildProduct.objects.insert(mainlessObject)
+                }
+            }
+            // The symbol removal tool on some platforms requires a separate file list in the file system.
+            try buildProduct.writeMainSymbolRemovalListFile(fileSystem)
+        }
 
         // Write the link filelist file.
         //
@@ -1527,6 +1565,7 @@ public class BuildPlan {
     ) -> (
         dylibs: [ResolvedProduct],
         staticTargets: [ResolvedTarget],
+        executableTargets: [ResolvedTarget],
         systemModules: [ResolvedTarget],
         libraryBinaryPaths: Set<AbsolutePath>
     ) {
@@ -1554,6 +1593,7 @@ public class BuildPlan {
         // Create empty arrays to collect our results.
         var linkLibraries = [ResolvedProduct]()
         var staticTargets = [ResolvedTarget]()
+        var executableTargets = [ResolvedTarget]()
         var systemModules = [ResolvedTarget]()
         var libraryBinaryPaths: Set<AbsolutePath> = []
 
@@ -1563,7 +1603,14 @@ public class BuildPlan {
                 switch target.type {
                 // Include executable and tests only if they're top level contents
                 // of the product. Otherwise they are just build time dependency.
-                case .executable, .test:
+                case .executable:
+                    if product.targets.contains(target) {
+                        staticTargets.append(target)
+                    }
+                    else {
+                        executableTargets.append(target)
+                    }
+                case .test:
                     if product.targets.contains(target) {
                         staticTargets.append(target)
                     }
@@ -1598,7 +1645,7 @@ public class BuildPlan {
             }
         }
 
-        return (linkLibraries, staticTargets, systemModules, libraryBinaryPaths)
+        return (linkLibraries, staticTargets, executableTargets, systemModules, libraryBinaryPaths)
     }
 
     /// Plan a Clang target.

Sources/Build/ManifestBuilder.swift

@@ -610,6 +610,30 @@ extension LLBuildManifestBuilder {
             outputs: [.file(target.wrappedModuleOutputPath)],
             args: moduleWrapArgs)
     }
+
+    /// Add a command to produce a new .o file that removes (or hides) the `_main` symbol from a compiled .o file.
+    /// This is used to modify .o files produced by executables so they can be linked into unit test products.  The
+    /// symbol list file is expected to only contain the symbol `_main` and is only needed because `nmedit` needs a
+    /// file with the names of the symbols.
+    private func addMainSymbolRemovalCmd(toolchain: Toolchain,
+                                         inputFile: AbsolutePath, outputFile: AbsolutePath,
+                                         mainSymbolListFile: AbsolutePath) {
+        let args = [
+            // FIXME: Using `nmedit` only works on Darwin.  For Linux (and Windows?) we need to use `strip` from the
+            //        `binutils`, and for other platforms, who knows.  This needs to be made generic.
+            // FIXME: Even on Darwin, we need the toolchain to provide the path of the `nmedit` tool.
+            toolchain.swiftCompiler.parentDirectory.appending(component: "nmedit").pathString,
+            "-R", mainSymbolListFile.pathString,
+            inputFile.pathString,
+            "-o", outputFile.pathString
+        ]
+        manifest.addShellCmd(
+            name: outputFile.pathString,
+            description: "Eliding symbols from \(outputFile.basename)",
+            inputs: [.file(inputFile)],  // Note: we don't add the symbol file as an input since it's a constant
+            outputs: [.file(outputFile)],
+            args: args)
+    }
 }
 
 // MARK:- Compile C-family
@@ -773,6 +797,11 @@ extension LLBuildManifestBuilder {
                 outputs: [.file(buildProduct.binary)],
                 args: buildProduct.linkArguments()
             )
+            
+            // Add a separate command to remove the main symbol.
+            for (mainlessObject, object) in buildProduct.executableObjects {
+                addMainSymbolRemovalCmd(toolchain: buildProduct.buildParameters.toolchain, inputFile: object, outputFile: mainlessObject, mainSymbolListFile: buildProduct.mainSymbolRemovalListFilePath)
+            }
         }
 
         // Create a phony node to represent the entire target.