[Build] Fix debugging for products built by SwiftPM

This implements proper debugging support on both Darwin and Linux. On
Darwin, this means SwiftPM will pass the swiftmodule file to the linker
and on Linux, it'll link the wrapped module obtained using Swift
compiler's modulewrap subtool.

<rdar://problem/29228963>
<rdar://problem/52118932>

https://bugs.swift.org/browse/SR-3280

Author: aciidgh

Sources/Build/BuildPlan.swift

@@ -229,6 +229,29 @@ public struct BuildParameters: Encodable {
         return BuildSettings.Scope(target.underlyingTarget.buildSettings, boundCondition: (currentPlatform, configuration))
     }
 
+    /// Represents the debugging strategy.
+    ///
+    /// Swift binaries requires the swiftmodule files in order for lldb to work.
+    /// On Darwin, linker can directly take the swiftmodule file path using the
+    /// -add_ast_path flag. On other platforms, we convert the swiftmodule into
+    /// an object file using Swift's modulewrap tool.
+    enum DebuggingStrategy {
+        case swiftAST
+        case modulewrap
+    }
+
+    /// The debugging strategy according to the current build parameters.
+    var debuggingStrategy: DebuggingStrategy? {
+        guard configuration == .debug else {
+            return nil
+        }
+
+        if triple.isDarwin() {
+            return .swiftAST
+        }
+        return .modulewrap
+    }
+
     /// A shim struct for toolchain so we can encode it without having to write encode(to:) for
     /// entire BuildParameters by hand.
     struct _Toolchain: Encodable {
@@ -488,6 +511,13 @@ public final class SwiftTargetBuildDescription {
         return buildParameters.buildPath.appending(component: target.c99name + ".swiftmodule")
     }
 
+    /// The path to the wrapped swift module which is created using the modulewrap tool. This is required
+    /// for supporting debugging on non-Darwin platforms (On Darwin, we just pass the swiftmodule to the linker
+    /// using the `-add_ast_path` flag).
+    var wrappedModuleOutputPath: AbsolutePath {
+        return tempsPath.appending(component: target.c99name + ".swiftmodule.o")
+    }
+
     /// The path to the swifinterface file after compilation.
     var parseableModuleInterfaceOutputPath: AbsolutePath {
         return buildParameters.buildPath.appending(component: target.c99name + ".swiftinterface")
@@ -747,6 +777,9 @@ public final class ProductBuildDescription {
     /// The list of targets that are going to be linked statically in this product.
     fileprivate var staticTargets: [ResolvedTarget] = []
 
+    /// The list of Swift modules that should be passed to the linker. This is required for debugging to work.
+    fileprivate var swiftASTs: [AbsolutePath] = []
+
     /// Path to the temporary directory for this product.
     var tempsPath: AbsolutePath {
         return buildParameters.buildPath.appending(component: product.name + ".product")
@@ -870,6 +903,10 @@ public final class ProductBuildDescription {
         // Add arguments from declared build settings.
         args += self.buildSettingsFlags()
 
+        // Add AST paths to make the product debuggable. This array is only populated when we're
+        // building for Darwin in debug configuration.
+        args += swiftASTs.flatMap{ ["-Xlinker", "-add_ast_path", "-Xlinker", $0.pathString] }
+
         // User arguments (from -Xlinker and -Xswiftc) should follow generated arguments to allow user overrides
         args += buildParameters.linkerFlags
         args += stripInvalidArguments(buildParameters.swiftCompilerFlags)
@@ -1184,6 +1221,28 @@ public class BuildPlan {
             }
         }
 
+        for target in dependencies.staticTargets {
+            switch target.underlyingTarget {
+            case is SwiftTarget:
+                // Swift targets are guaranteed to have a corresponding Swift description.
+                guard case .swift(let description) = targetMap[target]! else { fatalError() }
+
+                // Based on the debugging strategy, we either need to pass swiftmodule paths to the
+                // product or link in the wrapped module object. This is required for properly debugging
+                // Swift products. Debugging statergy is computed based on the current platform we're
+                // building for and is nil for the release configuration.
+                switch buildParameters.debuggingStrategy {
+                case .swiftAST:
+                    buildProduct.swiftASTs.append(description.moduleOutputPath)
+                case .modulewrap:
+                    buildProduct.objects += [description.wrappedModuleOutputPath]
+                case nil:
+                    break
+                }
+            default: break
+            }
+        }
+
         buildProduct.staticTargets = dependencies.staticTargets
         buildProduct.dylibs = dependencies.dylibs.map({ productMap[$0]! })
         buildProduct.objects += dependencies.staticTargets.flatMap({ targetMap[$0]!.objects })

Sources/Build/llbuild.swift

@@ -296,6 +296,20 @@ public final class LLBuildManifestGenerator {
         buildTarget.outputs.insert(target.moduleOutputPath.pathString)
         let tool = SwiftCompilerTool(target: target, inputs: inputs.values)
         buildTarget.cmds.insert(Command(name: target.target.getCommandName(config: buildConfig), tool: tool))
+
+        // Add commands to perform the module wrapping Swift modules when debugging statergy is `modulewrap`.
+        if plan.buildParameters.debuggingStrategy == .modulewrap {
+            let modulewrapTool = ShellTool(
+                description: "Wrapping AST for \(target.target.name) for debugging",
+                inputs: [target.moduleOutputPath.pathString],
+                outputs: [target.wrappedModuleOutputPath.pathString],
+                args: [target.buildParameters.toolchain.swiftCompiler.pathString,
+                       "-modulewrap", target.moduleOutputPath.pathString, "-o",
+                       target.wrappedModuleOutputPath.pathString],
+                allowMissingInputs: false)
+            buildTarget.cmds.insert(Command(name: target.wrappedModuleOutputPath.pathString, tool: modulewrapTool))
+        }
+
         return buildTarget
     }
 

Tests/BuildTests/BuildPlanTests.swift

@@ -114,7 +114,9 @@ final class BuildPlanTests: XCTestCase {
             "-emit-executable",
             "@/path/to/build/debug/exe.product/Objects.LinkFileList",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift/macosx",
-            "-target", "x86_64-apple-macosx10.10",
+            "-target", "x86_64-apple-macosx10.10", "-Xlinker", "-add_ast_path",
+            "-Xlinker", "/path/to/build/debug/exe.swiftmodule", "-Xlinker", "-add_ast_path",
+            "-Xlinker", "/path/to/build/debug/lib.swiftmodule",
         ]
       #else
         let linkArguments = [
@@ -461,6 +463,7 @@ final class BuildPlanTests: XCTestCase {
             "@/path/to/build/debug/exe.product/Objects.LinkFileList",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift/macosx",
             "-target", "x86_64-apple-macosx10.10",
+            "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/debug/exe.swiftmodule",
         ])
       #else
         XCTAssertEqual(try result.buildProduct(for: "exe").linkArguments(), [
@@ -604,6 +607,8 @@ final class BuildPlanTests: XCTestCase {
             "@/path/to/build/debug/PkgPackageTests.product/Objects.LinkFileList",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift/macosx",
             "-target", "x86_64-apple-macosx10.10",
+            "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/debug/FooTests.swiftmodule",
+            "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/debug/Foo.swiftmodule",
         ])
       #else
         XCTAssertEqual(try result.buildProduct(for: "PkgPackageTests").linkArguments(), [
@@ -656,6 +661,7 @@ final class BuildPlanTests: XCTestCase {
             "@/path/to/build/debug/exe.product/Objects.LinkFileList",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift/macosx",
             "-target", "x86_64-apple-macosx10.10",
+            "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/debug/exe.swiftmodule",
         ])
       #else
         XCTAssertEqual(try result.buildProduct(for: "exe").linkArguments(), [
@@ -749,6 +755,7 @@ final class BuildPlanTests: XCTestCase {
             "@/path/to/build/debug/Foo.product/Objects.LinkFileList",
             "-Xlinker", "-rpath", "-Xlinker", "/fake/path/lib/swift/macosx",
             "-target", "x86_64-apple-macosx10.10",
+            "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/debug/Foo.swiftmodule"
         ])
 
         XCTAssertEqual(barLinkArgs, [
@@ -757,6 +764,7 @@ final class BuildPlanTests: XCTestCase {
             "-module-name", "Bar_Baz", "-emit-library",
             "@/path/to/build/debug/Bar-Baz.product/Objects.LinkFileList",
             "-target", "x86_64-apple-macosx10.10",
+            "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/debug/Bar.swiftmodule"
         ])
       #else
         XCTAssertEqual(fooLinkArgs, [
@@ -824,6 +832,7 @@ final class BuildPlanTests: XCTestCase {
                 "-emit-library",
                 "@/path/to/build/debug/lib.product/Objects.LinkFileList",
                 "-target", "x86_64-apple-macosx10.10",
+                "-Xlinker", "-add_ast_path", "-Xlinker", "/path/to/build/debug/lib.swiftmodule",
             ]
         #else
             let linkArguments = [
@@ -1393,7 +1402,7 @@ final class BuildPlanTests: XCTestCase {
             XCTAssertMatch(exe, [.anySequence, "-DFOO", "-framework", "CoreData", .end])
 
             let linkExe = try result.buildProduct(for: "exe").linkArguments()
-            XCTAssertMatch(linkExe, [.anySequence, "-lsqlite3", "-llibz", "-framework", "CoreData", "-Ilfoo", "-L", "lbar", .end])
+            XCTAssertMatch(linkExe, [.anySequence, "-lsqlite3", "-llibz", "-framework", "CoreData", "-Ilfoo", "-L", "lbar", .anySequence])
         }
     }
 
@@ -1665,6 +1674,60 @@ final class BuildPlanTests: XCTestCase {
                  """))
          }
     }
+
+    func testModulewrap() throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Pkg/Sources/exe/main.swift",
+            "/Pkg/Sources/lib/lib.swift"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+        let graph = loadPackageGraph(root: "/Pkg", fs: fs, diagnostics: diagnostics,
+            manifests: [
+                Manifest.createV4Manifest(
+                    name: "Pkg",
+                    path: "/Pkg",
+                    url: "/Pkg",
+                    targets: [
+                        TargetDescription(name: "exe", dependencies: ["lib"]),
+                        TargetDescription(name: "lib", dependencies: []),
+                    ]
+                ),
+            ]
+        )
+        XCTAssertNoDiagnostics(diagnostics)
+
+        let result = BuildPlanResult(plan: try BuildPlan(
+            buildParameters: mockBuildParameters(destinationTriple: .x86_64Linux),
+            graph: graph, diagnostics: diagnostics, fileSystem: fs)
+        )
+
+        let objects = try result.buildProduct(for: "exe").objects
+        XCTAssertTrue(objects.contains(AbsolutePath("/path/to/build/debug/exe.build/exe.swiftmodule.o")), objects.description)
+        XCTAssertTrue(objects.contains(AbsolutePath("/path/to/build/debug/lib.build/lib.swiftmodule.o")), objects.description)
+
+        mktmpdir { path in
+            let yaml = path.appending(component: "debug.yaml")
+            let llbuild = LLBuildManifestGenerator(result.plan, client: "swift-build")
+            try llbuild.generateManifest(at: yaml)
+            let contents = try localFileSystem.readFileContents(yaml).description
+            XCTAssertMatch(contents, .contains("""
+                  "/path/to/build/debug/exe.build/exe.swiftmodule.o":
+                    tool: shell
+                    description: "Wrapping AST for exe for debugging"
+                    inputs: ["/path/to/build/debug/exe.swiftmodule"]
+                    outputs: ["/path/to/build/debug/exe.build/exe.swiftmodule.o"]
+                    args: ["/fake/path/to/swiftc","-modulewrap","/path/to/build/debug/exe.swiftmodule","-o","/path/to/build/debug/exe.build/exe.swiftmodule.o"]
+
+                  "/path/to/build/debug/lib.build/lib.swiftmodule.o":
+                    tool: shell
+                    description: "Wrapping AST for lib for debugging"
+                    inputs: ["/path/to/build/debug/lib.swiftmodule"]
+                    outputs: ["/path/to/build/debug/lib.build/lib.swiftmodule.o"]
+                    args: ["/fake/path/to/swiftc","-modulewrap","/path/to/build/debug/lib.swiftmodule","-o","/path/to/build/debug/lib.build/lib.swiftmodule.o"]
+                """))
+        }
+    }
 }
 
 // MARK:- Test Helpers