Implement -verify-debug-info

Author: owenv

Sources/SwiftDriver/Driver/Driver.swift

@@ -151,6 +151,9 @@ public struct Driver {
   /// Path to the optimization record.
   public let optimizationRecordPath: VirtualPath?
 
+  /// Whether 'dwarfdump' should be used to verify debug info.
+  public let shouldVerifyDebugInfo: Bool
+
   /// If the driver should force emit module in a single invocation.
   ///
   /// This will force the driver to first emit the module and then run compile jobs.
@@ -263,7 +266,8 @@ public struct Driver {
     self.numParallelJobs = Self.determineNumParallelJobs(&parsedOptions, diagnosticsEngine: diagnosticEngine, env: env)
 
     // Compute debug information output.
-    (self.debugInfoLevel, self.debugInfoFormat) = Self.computeDebugInfo(&parsedOptions, diagnosticsEngine: diagnosticEngine)
+    (self.debugInfoLevel, self.debugInfoFormat, shouldVerifyDebugInfo: self.shouldVerifyDebugInfo) =
+      Self.computeDebugInfo(&parsedOptions, diagnosticsEngine: diagnosticEngine)
 
     // Determine the module we're building and whether/how the module file itself will be emitted.
     (self.moduleOutput, self.moduleName) = try Self.computeModuleInfo(
@@ -948,10 +952,12 @@ extension Diagnostic.Message {
 // Debug information
 extension Driver {
   /// Compute the level of debug information we are supposed to produce.
-  private static func computeDebugInfo(_ parsedOptions: inout ParsedOptions, diagnosticsEngine: DiagnosticsEngine) -> (DebugInfoLevel?, DebugInfoFormat) {
+  private static func computeDebugInfo(_ parsedOptions: inout ParsedOptions, diagnosticsEngine: DiagnosticsEngine) -> (DebugInfoLevel?, DebugInfoFormat, shouldVerifyDebugInfo: Bool) {
+    var shouldVerify = parsedOptions.hasArgument(.verifyDebugInfo)
+
     // Determine the debug level.
     let level: DebugInfoLevel?
-    if let levelOption = parsedOptions.getLast(in: .g) {
+    if let levelOption = parsedOptions.getLast(in: .g), levelOption.option != .gnone {
       switch levelOption.option {
       case .g:
         level = .astTypes
@@ -962,14 +968,16 @@ extension Driver {
       case .gdwarfTypes:
         level = .dwarfTypes
 
-      case .gnone:
-        level = nil
-
       default:
         fatalError("Unhandle option in the '-g' group")
       }
     } else {
+      // -gnone, or no debug level specified
       level = nil
+      if shouldVerify {
+        shouldVerify = false
+        diagnosticsEngine.emit(.verify_debug_info_requires_debug_option)
+      }
     }
 
     // Determine the debug info format.
@@ -995,7 +1003,7 @@ extension Driver {
       diagnosticsEngine.emit(.error_argument_not_allowed_with(arg: format.rawValue, other: levelOption.spelling))
     }
 
-    return (level, format)
+    return (level, format, shouldVerifyDebugInfo: shouldVerify)
   }
 
   /// Parses the set of `-sanitize={sanitizer}` arguments and returns all the
@@ -1074,6 +1082,12 @@ extension Driver {
 
 }
 
+extension Diagnostic.Message {
+  static var verify_debug_info_requires_debug_option: Diagnostic.Message {
+    .warning("ignoring '-verify-debug-info'; no debug info is being generated")
+  }
+}
+
 // Module computation.
 extension Driver {
   /// Compute the base name of the given path without an extension.

Sources/SwiftDriver/Jobs/Job.swift

@@ -22,6 +22,7 @@ public struct Job: Codable, Equatable {
     case emitModule = "emit-module"
     case interpret
     case repl
+    case verifyDebugInfo = "verify-debug-info"
   }
 
   public enum ArgTemplate: Equatable {

Sources/SwiftDriver/Jobs/Planning.swift

@@ -144,7 +144,11 @@ extension Driver {
 
     // If we should generate a dSYM, do so.
     if let linkJob = link, targetTriple.isDarwin, debugInfoLevel != nil {
-      jobs.append(try generateDSYMJob(inputs: linkJob.outputs))
+      let dsymJob = try generateDSYMJob(inputs: linkJob.outputs)
+      jobs.append(dsymJob)
+      if shouldVerifyDebugInfo {
+        jobs.append(try verifyDebugInfoJob(inputs: dsymJob.outputs))
+      }
     }
 
     // FIXME: Lots of follow-up actions for merging modules, etc.

Sources/SwiftDriver/Jobs/VerifyDebugInfoJob.swift

@@ -0,0 +1,32 @@
+//===------- VerifyDebugInfoJob.swift - Swift Debug Info Verification -----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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 {
+  func verifyDebugInfoJob(inputs: [TypedVirtualPath]) throws -> Job {
+    assert(inputs.count == 1)
+    let input = inputs[0]
+
+    // This mirrors the clang driver's --verify-debug-info option.
+    var commandLine = [Job.ArgTemplate]()
+    commandLine.appendFlags("--verify", "--debug-info", "--eh-frame", "--quiet")
+    commandLine.appendPath(input.file)
+
+    return Job(
+      kind: .verifyDebugInfo,
+      tool: .absolute(try toolchain.getToolPath(.dwarfdump)),
+      commandLine: commandLine,
+      displayInputs: [],
+      inputs: inputs,
+      outputs: []
+    )
+  }
+}

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -46,6 +46,8 @@ public final class DarwinToolchain: Toolchain {
       return try lookup(executable: "swift-autolink-extract")
     case .lldb:
       return try lookup(executable: "lldb")
+    case .dwarfdump:
+      return try lookup(executable: "dwarfdump")
     }
   }
 

Sources/SwiftDriver/Toolchains/GenericUnixToolchain.swift

@@ -44,6 +44,8 @@ public final class GenericUnixToolchain: Toolchain {
       return try lookup(executable: "dsymutil")
     case .lldb:
       return try lookup(executable: "lldb")
+    case .dwarfdump:
+      return try lookup(executable: "dwarfdump")
     }
   }
 

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -20,6 +20,7 @@ public enum Tool {
   case swiftAutolinkExtract
   case dsymutil
   case lldb
+  case dwarfdump
 }
 
 /// Describes a toolchain, which includes information about compilers, linkers

Tests/SwiftDriverTests/Helpers/AssertDiagnostics.swift

@@ -14,9 +14,9 @@ import XCTest
 import SwiftDriver
 import TSCBasic
 
-fileprivate func assertDriverDiagnostics(
+func assertDriverDiagnostics(
   args: [String],
-  env: [String: String],
+  env: [String: String] = ProcessEnv.vars,
   file: StaticString = #file, line: UInt = #line,
   do body: (inout Driver, DiagnosticVerifier) throws -> Void
 ) throws {

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -1081,6 +1081,50 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
+  func testVerifyDebugInfo() throws {
+    let commonArgs = [
+      "swiftc", "foo.swift", "bar.swift",
+      "-emit-executable", "-module-name", "Test", "-verify-debug-info"
+    ]
+
+    // No dSYM generation (no -g), therefore no verification
+    try assertDriverDiagnostics(args: commonArgs) { driver, verifier in
+      verifier.expect(.warning("ignoring '-verify-debug-info'; no debug info is being generated"))
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 3)
+      XCTAssertFalse(plannedJobs.contains { $0.kind == .verifyDebugInfo })
+    }
+
+    // No dSYM generation (-gnone), therefore no verification
+    try assertDriverDiagnostics(args: commonArgs + ["-gnone"]) { driver, verifier in
+      verifier.expect(.warning("ignoring '-verify-debug-info'; no debug info is being generated"))
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 3)
+      XCTAssertFalse(plannedJobs.contains { $0.kind == .verifyDebugInfo })
+    }
+
+    do {
+      // dSYM generation and verification (-g + -verify-debug-info)
+      var driver = try Driver(args: commonArgs + ["-g"])
+      let plannedJobs = try driver.planBuild()
+
+      let verifyDebugInfoJob = plannedJobs.last!
+      let cmd = verifyDebugInfoJob.commandLine
+
+      if driver.targetTriple.isDarwin {
+        XCTAssertEqual(plannedJobs.count, 6)
+        XCTAssertEqual(verifyDebugInfoJob.inputs.first?.file, try VirtualPath(path: "Test.dSYM"))
+        XCTAssertTrue(cmd.contains(.flag("--verify")))
+        XCTAssertTrue(cmd.contains(.flag("--debug-info")))
+        XCTAssertTrue(cmd.contains(.flag("--eh-frame")))
+        XCTAssertTrue(cmd.contains(.flag("--quiet")))
+        XCTAssertTrue(cmd.contains(.path(try VirtualPath(path: "Test.dSYM"))))
+      } else {
+        XCTAssertEqual(plannedJobs.count, 4)
+      }
+    }
+  }
+
   func testDOTFileEmission() throws {
     var driver = try Driver(args: [
       "swiftc", "-emit-executable", "test.swift", "-emit-module"