Support module wrapping for debugging on Linux

Author: owenv

Sources/SwiftDriver/Jobs/Job.swift

@@ -23,6 +23,7 @@ public struct Job: Codable, Equatable, Hashable {
     case autolinkExtract = "autolink-extract"
     case emitModule = "emit-module"
     case generatePCH = "generate-pch"
+    case moduleWrap = "module-wrap"
 
     /// Generate a compiled Clang module.
     case generatePCM = "generate-pcm"
@@ -145,6 +146,9 @@ extension Job : CustomStringConvertible {
     case .generatePCH:
         return "Compiling bridging header \(displayInputs.first?.file.basename ?? "")"
 
+    case .moduleWrap:
+      return "Wrapping Swift module \(moduleName)"
+
     case .generatePCM:
         return "Compiling Clang module \(displayInputs.first?.file.basename  ?? "")"
 
@@ -184,7 +188,7 @@ extension Job.Kind {
         .versionRequest, .scanDependencies:
         return true
 
-    case .autolinkExtract, .generateDSYM, .help, .link, .verifyDebugInfo:
+    case .autolinkExtract, .generateDSYM, .help, .link, .verifyDebugInfo, .moduleWrap:
         return false
     }
   }
@@ -197,7 +201,8 @@ extension Job.Kind {
     case .backend, .mergeModule, .emitModule, .generatePCH,
          .generatePCM, .interpret, .repl, .printTargetInfo,
          .versionRequest, .autolinkExtract, .generateDSYM,
-         .help, .link, .verifyDebugInfo, .scanDependencies:
+         .help, .link, .verifyDebugInfo, .scanDependencies,
+         .moduleWrap:
       return false
     }
   }

Sources/SwiftDriver/Jobs/ModuleWrapJob.swift

@@ -0,0 +1,39 @@
+//===--------------- ModuleWrapJob.swift - Swift Module Wrapping ----------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+extension Driver {
+  mutating func moduleWrapJob(moduleInput: TypedVirtualPath) throws -> Job {
+    var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
+
+    commandLine.appendFlags("-modulewrap")
+
+    // Add the input.
+    commandLine.append(.path(moduleInput.file))
+    assert(compilerOutputType == .object, "-modulewrap mode only produces object files")
+
+    commandLine.appendFlags("-target", targetTriple.triple)
+
+    let outputPath = try moduleInput.file.replacingExtension(with: .object)
+    commandLine.appendFlag("-o")
+    commandLine.appendPath(outputPath)
+
+    return Job(
+      moduleName: moduleOutputInfo.name,
+      kind: .moduleWrap,
+      tool: .absolute(try toolchain.getToolPath(.swiftCompiler)),
+      commandLine: commandLine,
+      inputs: [moduleInput],
+      outputs: [.init(file: outputPath, type: .object)],
+      supportsResponseFiles: true
+    )
+  }
+}

Sources/SwiftDriver/Jobs/Planning.swift

@@ -188,8 +188,10 @@ extension Driver {
     jobs.append(contentsOf: backendJobs)
 
     // Plan the merge-module job, if there are module inputs.
+    var mergeJob: Job?
     if moduleOutputInfo.output != nil && !moduleInputs.isEmpty && compilerMode.usesPrimaryFileInputs {
-      jobs.append(try mergeModuleJob(inputs: moduleInputs))
+      mergeJob = try mergeModuleJob(inputs: moduleInputs)
+      jobs.append(mergeJob!)
     }
 
     // If we need to autolink-extract, do so.
@@ -199,6 +201,20 @@ extension Driver {
       jobs.append(autolinkExtractJob)
     }
 
+    if let mergeJob = mergeJob, debugInfo.level == .astTypes {
+      if targetTriple.objectFormat != .macho {
+        // Module wrapping is required.
+        let mergeModuleOutputs = mergeJob.outputs.filter { $0.type == .swiftModule }
+        assert(mergeModuleOutputs.count == 1,
+               "Merge module job should only have one swiftmodule output")
+        let wrapJob = try moduleWrapJob(moduleInput: mergeModuleOutputs[0])
+        linkerInputs.append(contentsOf: wrapJob.outputs)
+        jobs.append(wrapJob)
+      } else {
+        linkerInputs.append(contentsOf: mergeJob.outputs)
+      }
+    }
+
     // If we should link, do so.
     var link: Job?
     if linkerOutputType != nil && !linkerInputs.isEmpty {

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -1309,6 +1309,52 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
+  func testModuleWrapJob() throws {
+    do {
+      var driver = try Driver(args: ["swiftc", "-target", "x86_64-unknown-linux-gnu", "-g", "foo.swift"])
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 4)
+      // FIXME: There should also be an autolink-extract job. It looks like our
+      // triple parsing code is not detecting the object file format correctly.
+      XCTAssertEqual(plannedJobs.map { $0.kind }, [.compile, .mergeModule, .moduleWrap, .link])
+      XCTAssertEqual(plannedJobs[2].inputs.count, 1)
+      XCTAssertEqual(plannedJobs[2].inputs.count, 1)
+      XCTAssertTrue(plannedJobs[2].commandLine.contains(subsequence: ["-target", "x86_64-unknown-linux-gnu"]))
+      XCTAssertTrue(plannedJobs[1].outputs.contains(plannedJobs[2].inputs.first!))
+      XCTAssertTrue(plannedJobs[3].inputs.contains(plannedJobs[2].outputs.first!))
+    }
+
+    do {
+      var driver = try Driver(args: ["swiftc", "-target", "x86_64-apple-macosx10.15", "-g", "foo.swift"])
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 4)
+      // No module wrapping with Mach-O.
+      // FIXME: There should also be an autolink-extract job. It looks like our
+      // triple parsing code is not detecting the object file format correctly.
+      XCTAssertEqual(plannedJobs.map { $0.kind }, [.compile, .mergeModule, .link, .generateDSYM])
+    }
+
+    do {
+      var driver = try Driver(args: ["swiftc", "-target", "x86_64-unknown-linux-gnu", "foo.swift"])
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 2)
+      // No merge module/module wrap jobs.
+      // FIXME: There should also be an autolink-extract job. It looks like our
+      // triple parsing code is not detecting the object file format correctly.
+      XCTAssertEqual(plannedJobs.map { $0.kind }, [.compile, .link])
+    }
+
+    do {
+      var driver = try Driver(args: ["swiftc", "-target", "x86_64-unknown-linux-gnu", "-gdwarf-types", "foo.swift"])
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 3)
+      // Merge module, but no module wrapping.
+      // FIXME: There should also be an autolink-extract job. It looks like our
+      // triple parsing code is not detecting the object file format correctly.
+      XCTAssertEqual(plannedJobs.map { $0.kind }, [.compile, .mergeModule, .link])
+    }
+  }
+
   func testRepl() throws {
 
     func isLLDBREPLFlag(_ arg: Job.ArgTemplate) -> Bool {

Tests/SwiftDriverTests/XCTestManifests.swift

@@ -21,6 +21,7 @@ extension ExplicitModuleBuildTests {
         ("testExplicitModuleBuildJobs", testExplicitModuleBuildJobs),
         ("testExplicitSwiftModuleMap", testExplicitSwiftModuleMap),
         ("testModuleDependencyBuildCommandGeneration", testModuleDependencyBuildCommandGeneration),
+        ("testModuleDependencyWithExternalCommandGeneration", testModuleDependencyWithExternalCommandGeneration),
     ]
 }
 
@@ -107,6 +108,7 @@ extension SwiftDriverTests {
         ("testModuleNameFallbacks", testModuleNameFallbacks),
         ("testModuleNaming", testModuleNaming),
         ("testModuleSettings", testModuleSettings),
+        ("testModuleWrapJob", testModuleWrapJob),
         ("testMultiThreadedWholeModuleOptimizationCompiles", testMultiThreadedWholeModuleOptimizationCompiles),
         ("testMultithreading", testMultithreading),
         ("testMultithreadingDiagnostics", testMultithreadingDiagnostics),