diff --git a/Sources/SwiftDriver/Driver/Driver.swift b/Sources/SwiftDriver/Driver/Driver.swift
index a3ab322f3..f3149e5d6 100644
--- a/Sources/SwiftDriver/Driver/Driver.swift
+++ b/Sources/SwiftDriver/Driver/Driver.swift
@@ -773,7 +773,10 @@ public struct Driver {
                                diagnosticsEngine: diagnosticEngine)
 
     // Compute debug information output.
-    self.debugInfo = Self.computeDebugInfo(&parsedOptions, diagnosticsEngine: diagnosticEngine)
+    let defaultDwarfVersion = self.toolchain.getDefaultDwarfVersion(targetTriple: self.frontendTargetInfo.target.triple)
+    self.debugInfo = Self.computeDebugInfo(&parsedOptions,
+                                           defaultDwarfVersion: defaultDwarfVersion,
+                                           diagnosticsEngine: diagnosticEngine)
 
     // Error if package-name is passed but the input is empty; if
     // package-name is not passed but `package` decls exist, error
@@ -2323,7 +2326,9 @@ 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) -> DebugInfo {
+  private static func computeDebugInfo(_ parsedOptions: inout ParsedOptions,
+                                       defaultDwarfVersion : UInt8,
+                                       diagnosticsEngine: DiagnosticsEngine) -> DebugInfo {
     var shouldVerify = parsedOptions.hasArgument(.verifyDebugInfo)
 
     for debugPrefixMap in parsedOptions.arguments(for: .debugPrefixMap) {
@@ -2392,7 +2397,7 @@ extension Driver {
     }
 
     // Determine the DWARF version.
-    var dwarfVersion: UInt8 = 4
+    var dwarfVersion: UInt8 = defaultDwarfVersion
     if let versionArg = parsedOptions.getLastArgument(.dwarfVersion) {
       if let parsedVersion = UInt8(versionArg.asSingle), parsedVersion >= 2 && parsedVersion <= 5 {
         dwarfVersion = parsedVersion
diff --git a/Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift b/Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift
index 6d0d266d0..e82beab26 100644
--- a/Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift
+++ b/Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift
@@ -195,8 +195,10 @@ extension Driver {
     try commandLine.appendLast(.enableTesting, from: &parsedOptions)
     try commandLine.appendLast(.enablePrivateImports, from: &parsedOptions)
     try commandLine.appendLast(in: .g, from: &parsedOptions)
-    try commandLine.appendLast(.debugInfoFormat, from: &parsedOptions)
-    try commandLine.appendLast(.dwarfVersion, from: &parsedOptions)
+    if debugInfo.level != nil {
+      commandLine.appendFlag("-debug-info-format=\(debugInfo.format)")
+      commandLine.appendFlag("-dwarf-version=\(debugInfo.dwarfVersion)")
+    }
     try commandLine.appendLast(.importUnderlyingModule, from: &parsedOptions)
     try commandLine.appendLast(.moduleCachePath, from: &parsedOptions)
     try commandLine.appendLast(.moduleLinkName, from: &parsedOptions)
diff --git a/Sources/SwiftDriver/Toolchains/DarwinToolchain.swift b/Sources/SwiftDriver/Toolchains/DarwinToolchain.swift
index fd523655c..0c70e25ac 100644
--- a/Sources/SwiftDriver/Toolchains/DarwinToolchain.swift
+++ b/Sources/SwiftDriver/Toolchains/DarwinToolchain.swift
@@ -219,6 +219,15 @@ public final class DarwinToolchain: Toolchain {
     }
   }
 
+  public func getDefaultDwarfVersion(targetTriple: Triple) -> UInt8 {
+      if (targetTriple.isMacOSX && targetTriple.version(for: .macOS) < Triple.Version(10, 11, 0)) ||
+        (targetTriple.isiOS && targetTriple.version(
+            for: .iOS(targetTriple._isSimulatorEnvironment ? .simulator : .device)) < Triple.Version(9, 0, 0)) {
+      return 2;
+    }
+    return 4
+  }
+
   func validateDeploymentTarget(_ parsedOptions: inout ParsedOptions,
                                 targetTriple: Triple, compilerOutputType: FileType?) throws {
     guard let os = targetTriple.os else {
diff --git a/Sources/SwiftDriver/Toolchains/Toolchain.swift b/Sources/SwiftDriver/Toolchains/Toolchain.swift
index c5fdad5c8..77986bcfc 100644
--- a/Sources/SwiftDriver/Toolchains/Toolchain.swift
+++ b/Sources/SwiftDriver/Toolchains/Toolchain.swift
@@ -122,6 +122,9 @@ public protocol Toolchain {
                     compilerOutputType: FileType?,
                     diagnosticsEngine: DiagnosticsEngine) throws
 
+  /// Return the DWARF version to emit, in the absence of arguments to the contrary.
+  func getDefaultDwarfVersion(targetTriple: Triple) -> UInt8
+
   /// Adds platform-specific linker flags to the provided command line
   func addPlatformSpecificLinkerArgs(
     to commandLine: inout [Job.ArgTemplate],
@@ -331,6 +334,8 @@ extension Toolchain {
                            compilerOutputType: FileType?,
                            diagnosticsEngine: DiagnosticsEngine) {}
 
+  public func getDefaultDwarfVersion(targetTriple: Triple) -> UInt8 { return 4 }
+
   public func addPlatformSpecificCommonFrontendOptions(
     commandLine: inout [Job.ArgTemplate],
     inputs: inout [TypedVirtualPath],
diff --git a/Tests/SwiftDriverTests/SwiftDriverTests.swift b/Tests/SwiftDriverTests/SwiftDriverTests.swift
index 5030b3e7d..b48e70b1d 100644
--- a/Tests/SwiftDriverTests/SwiftDriverTests.swift
+++ b/Tests/SwiftDriverTests/SwiftDriverTests.swift
@@ -593,6 +593,39 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertTrue(jobs[0].commandLine.contains(.flag(".")))
     }
 
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-g", "-c", "-target", "x86_64-apple-macosx10.10") { driver in
+      let jobs = try driver.planBuild()
+      XCTAssertTrue(jobs[0].commandLine.contains(.flag("-dwarf-version=2")))
+    }
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-g", "-c", "-target", "x86_64-apple-macosx10.11") { driver in
+      let jobs = try driver.planBuild()
+      XCTAssertTrue(jobs[0].commandLine.contains(.flag("-dwarf-version=4")))
+    }
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-g", "-c", "-target", "x86_64-apple-macos14.0") { driver in
+      let jobs = try driver.planBuild()
+      XCTAssertTrue(jobs[0].commandLine.contains(.flag("-dwarf-version=4")))
+    }
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-g", "-c", "-target", "arm64-apple-ios8.0") { driver in
+      let jobs = try driver.planBuild()
+      XCTAssertTrue(jobs[0].commandLine.contains(.flag("-dwarf-version=2")))
+    }
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-g", "-c", "-target", "arm64-apple-ios9.0") { driver in
+      let jobs = try driver.planBuild()
+      XCTAssertTrue(jobs[0].commandLine.contains(.flag("-dwarf-version=4")))
+    }
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-g", "-c", "-target", "x86_64-apple-ios17-macabi") { driver in
+      let jobs = try driver.planBuild()
+      XCTAssertTrue(jobs[0].commandLine.contains(.flag("-dwarf-version=4")))
+    }
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-g", "-c", "-target", "arm64-apple-tvos17.0") { driver in
+      let jobs = try driver.planBuild()
+      XCTAssertTrue(jobs[0].commandLine.contains(.flag("-dwarf-version=4")))
+    }
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-g", "-c", "-target", "arm64_32-apple-watchos10.0") { driver in
+      let jobs = try driver.planBuild()
+      XCTAssertTrue(jobs[0].commandLine.contains(.flag("-dwarf-version=4")))
+    }
+
     try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-c", "-file-compilation-dir", ".") { driver in
       let jobs = try driver.planBuild()
       XCTAssertFalse(jobs[0].commandLine.contains(.flag("-file-compilation-dir")))