Merge pull request #2348 from aciidb0mb3r/debugging

[Build] Fix debugging for products built by SwiftPM

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