Build: centralise the debug information flag handling

Rather than spreading out the flag addition across the various different
targets, we can control the flags at the `BuildParameters` level,
driving the necessary flag addition at a single site.  This would allow
easier management of the flags as we can see the additions uniformly
applied.

This shuffles the previously introduced functionality from `SwiftTool`
and sinks it into `BuildParameters`.  This enables the application of
the flags without having to go through the tooling, i.e. when SPM is
used as a library.

The test changes alter the expectations for ordering and additional
flags being applied for various compilation cases.

Author: compnerd

Sources/Build/BuildDescription/ClangTargetBuildDescription.swift

@@ -220,10 +220,7 @@ public final class ClangTargetBuildDescription {
             args += ["-fobjc-arc"]
         }
         args += try buildParameters.targetTripleArgs(for: target)
-        args += ["-g"]
-        if buildParameters.triple.isWindows() {
-            args += ["-gcodeview"]
-        }
+
         args += optimizationArguments
         args += activeCompilationConditions
         args += ["-fblocks"]

Sources/Build/BuildDescription/ProductBuildDescription.swift

@@ -158,15 +158,6 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
             args += ["-v"]
         }
 
-        // Pass `-g` during a *release* build so the Swift driver emits a dSYM file for the binary.
-        if self.buildParameters.configuration == .release {
-            if self.buildParameters.triple.isWindows() {
-                args += ["-Xlinker", "-debug"]
-            } else {
-                args += ["-g"]
-            }
-        }
-
         // Only add the build path to the framework search path if there are binary frameworks to link against.
         if !self.libraryBinaryPaths.isEmpty {
             args += ["-F", self.buildParameters.buildPath.pathString]

Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift

@@ -441,7 +441,7 @@ public final class SwiftTargetBuildDescription {
         args += self.buildParameters.indexStoreArguments(for: self.target)
         args += self.optimizationArguments
         args += self.testingArguments
-        args += ["-g"]
+
         args += ["-j\(self.buildParameters.workers)"]
         args += self.activeCompilationConditions
         args += self.additionalFlags
@@ -627,7 +627,7 @@ public final class SwiftTargetBuildDescription {
         result += ["-swift-version", self.swiftVersion.rawValue]
         result += self.optimizationArguments
         result += self.testingArguments
-        result += ["-g"]
+
         result += ["-j\(self.buildParameters.workers)"]
         result += self.activeCompilationConditions
         result += self.additionalFlags
@@ -686,7 +686,7 @@ public final class SwiftTargetBuildDescription {
         result += self.buildParameters.indexStoreArguments(for: self.target)
         result += self.optimizationArguments
         result += self.testingArguments
-        result += ["-g"]
+
         result += ["-j\(self.buildParameters.workers)"]
         result += self.activeCompilationConditions
         result += self.additionalFlags

Sources/CoreCommands/Options.swift

@@ -504,8 +504,11 @@ public struct BuildOptions: ParsableArguments {
         case thin
     }
 
+    /// See `BuildParameters.DebugInfoFormat` for details.
     public enum DebugInfoFormat: String, Codable, ExpressibleByArgument {
+        /// See `BuildParameters.DebugInfoFormat.dwarf` for details.
         case dwarf
+        /// See `BuildParameters.DebugInfoFormat.codeview` for details.
         case codeview
     }
 }

Sources/CoreCommands/SwiftTool.swift

@@ -678,33 +678,12 @@ public final class SwiftTool {
                 component: destinationTriple.platformBuildPathComponent(buildSystem: options.build.buildSystem)
             )
 
-            var flags: BuildFlags = options.build.buildFlags
-            if destinationTriple.isWindows() {
-                switch options.build.debugInfoFormat {
-                case .dwarf:
-                    // DWARF requires lld as link.exe expects CodeView debug info.
-                    flags = flags.merging(BuildFlags(
-                        cCompilerFlags: ["-gdwarf"],
-                        cxxCompilerFlags: ["-gdwarf"],
-                        swiftCompilerFlags: ["-g", "-use-ld=lld"],
-                        linkerFlags: ["-debug:dwarf"]
-                    ))
-                case .codeview:
-                    flags = flags.merging(BuildFlags(
-                        swiftCompilerFlags: ["-g", "-debug-info-format=codeview"],
-                        linkerFlags: ["-debug"]
-                    ))
-                }
-            } else if options.build.debugInfoFormat == .codeview {
-                observabilityScope.emit(error: "CodeView debug information is currently not supported for this platform")
-            }
-
             return try BuildParameters(
                 dataPath: dataPath,
                 configuration: options.build.configuration,
                 toolchain: destinationToolchain,
                 destinationTriple: destinationTriple,
-                flags: flags,
+                flags: options.build.buildFlags,
                 pkgConfigDirectories: options.locations.pkgConfigDirectories,
                 architectures: options.build.architectures,
                 workers: options.build.jobs ?? UInt32(ProcessInfo.processInfo.activeProcessorCount),
@@ -725,7 +704,8 @@ public final class SwiftTool {
                 explicitTargetDependencyImportCheckingMode: options.build.explicitTargetDependencyImportCheck.modeParameter,
                 linkerDeadStrip: options.linker.linkerDeadStrip,
                 verboseOutput: self.logLevel <= .info,
-                linkTimeOptimizationMode: options.build.linkTimeOptimizationMode?.buildParameter
+                linkTimeOptimizationMode: options.build.linkTimeOptimizationMode?.buildParameter,
+                debugInfoFormat: options.build.debugInfoFormat.buildParameter
             )
         })
     }()
@@ -999,6 +979,17 @@ extension BuildOptions.LinkTimeOptimizationMode {
     }
 }
 
+extension BuildOptions.DebugInfoFormat {
+    fileprivate var buildParameter: BuildParameters.DebugInfoFormat {
+        switch self {
+        case .dwarf:
+            return .dwarf
+        case .codeview:
+            return .codeview
+        }
+    }
+}
+
 extension Basics.Diagnostic {
     public static func mutuallyExclusiveArgumentsError(arguments: [String]) -> Self {
         .error(arguments.map { "'\($0)'" }.spm_localizedJoin(type: .conjunction) + " are mutually exclusive")

Sources/SPMBuildCore/BuildParameters.swift

@@ -52,6 +52,18 @@ public struct BuildParameters: Encodable {
         case thin
     }
 
+    /// Represents the debug information format.
+    ///
+    /// The debug information format controls the format of the debug information
+    /// that the compiler generates.  Some platforms support debug information
+    // formats other than DWARF.
+    public enum DebugInfoFormat: String, Encodable {
+        /// DWARF debug information format, the default format used by Swift.
+        case dwarf
+        /// CodeView debug information format, used on Windows.
+        case codeview
+    }
+
     /// Represents the debugging strategy.
     ///
     /// Swift binaries requires the swiftmodule files in order for lldb to work.
@@ -247,6 +259,8 @@ public struct BuildParameters: Encodable {
 
     public var linkTimeOptimizationMode: LinkTimeOptimizationMode?
 
+    public var debugInfoFormat: DebugInfoFormat
+
     public init(
         dataPath: AbsolutePath,
         configuration: BuildConfiguration,
@@ -276,7 +290,8 @@ public struct BuildParameters: Encodable {
         linkerDeadStrip: Bool = true,
         colorizedOutput: Bool = false,
         verboseOutput: Bool = false,
-        linkTimeOptimizationMode: LinkTimeOptimizationMode? = nil
+        linkTimeOptimizationMode: LinkTimeOptimizationMode? = nil,
+        debugInfoFormat: DebugInfoFormat = .dwarf
     ) throws {
         let triple = try destinationTriple ?? .getHostTriple(usingSwiftCompiler: toolchain.swiftCompilerPath)
 
@@ -285,7 +300,28 @@ public struct BuildParameters: Encodable {
         self._toolchain = _Toolchain(toolchain: toolchain)
         self.hostTriple = try hostTriple ?? .getHostTriple(usingSwiftCompiler: toolchain.swiftCompilerPath)
         self.triple = triple
-        self.flags = flags
+        switch debugInfoFormat {
+        case .dwarf:
+            var flags = flags
+            // DWARF requires lld as link.exe expects CodeView debug info.
+            self.flags = flags.merging(triple.isWindows() ? BuildFlags(
+                cCompilerFlags: ["-gdwarf"],
+                cxxCompilerFlags: ["-gdwarf"],
+                swiftCompilerFlags: ["-g", "-use-ld=lld"],
+                linkerFlags: ["-debug:dwarf"]
+            ) : BuildFlags(cCompilerFlags: ["-g"], cxxCompilerFlags: ["-g"], swiftCompilerFlags: ["-g"]))
+        case .codeview:
+            if !triple.isWindows() {
+                throw StringError("CodeView debug information is currently not supported on \(triple.osName)")
+            }
+            var flags = flags
+            self.flags = flags.merging(BuildFlags(
+                cCompilerFlags: ["-g"],
+                cxxCompilerFlags: ["-g"],
+                swiftCompilerFlags: ["-g", "-debug-info-format=codeview"],
+                linkerFlags: ["-debug"]
+            ))
+        }
         self.pkgConfigDirectories = pkgConfigDirectories
         self.architectures = architectures
         self.workers = workers
@@ -318,6 +354,7 @@ public struct BuildParameters: Encodable {
         self.colorizedOutput = colorizedOutput
         self.verboseOutput = verboseOutput
         self.linkTimeOptimizationMode = linkTimeOptimizationMode
+        self.debugInfoFormat = debugInfoFormat
     }
 
     public func withDestination(_ destinationTriple: Triple) throws -> BuildParameters {