pass -fno-omit-frame-pointer in support of new backtracer

Sources/Build/BuildDescription/ClangTargetBuildDescription.swift

@@ -301,6 +301,17 @@ public final class ClangTargetBuildDescription {
             args += ["-flto=thin"]
         }
 
+        // rdar://117578677
+        // Pass -fno-omit-frame-pointer to support backtraces
+        // this can be removed once the backtracer uses DWARF instead of frame pointers
+        if let omitFramePointers = self.buildParameters.debuggingParameters.omitFramePointers {
+            if omitFramePointers {
+                args += ["-fomit-frame-pointer"]
+            } else {
+                args += ["-fno-omit-frame-pointer"]
+            }
+        }
+
         // Pass default include paths from the toolchain.
         for includeSearchPath in self.buildParameters.toolchain.includeSearchPaths {
             args += ["-I", includeSearchPath.pathString]

Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift

@@ -589,6 +589,17 @@ public final class SwiftTargetBuildDescription {
 
         args += self.packageNameArgumentIfSupported(with: self.package, packageAccess: self.target.packageAccess)
         args += try self.macroArguments()
+
+        // rdar://117578677
+        // Pass -fno-omit-frame-pointer to support backtraces
+        // this can be removed once the backtracer uses DWARF instead of frame pointers
+        if let omitFramePointers = self.buildParameters.debuggingParameters.omitFramePointers {
+            if omitFramePointers {
+                args += ["-Xcc", "-fomit-frame-pointer"]
+            } else {
+                args += ["-Xcc", "-fno-omit-frame-pointer"]
+            }
+        }
 
         return args
     }

Sources/CoreCommands/Options.swift

@@ -480,6 +480,11 @@ public struct BuildOptions: ParsableArguments {
     @Flag(inversion: .prefixedEnableDisable, help: .hidden)
     public var getTaskAllowEntitlement: Bool? = nil
 
+    // Whether to omit frame pointers
+    // this can be removed once the backtracer uses DWARF instead of frame pointers
+    @Flag(inversion: .prefixedNo,  help: .hidden)
+    public var omitFramePointers: Bool? = nil
+
     // @Flag works best when there is a default value present
     // if true, false aren't enough and a third state is needed
     // nil should not be the goto. Instead create an enum

Sources/CoreCommands/SwiftTool.swift

@@ -703,7 +703,8 @@ public final class SwiftTool {
                 debugInfoFormat: options.build.debugInfoFormat.buildParameter,
                 targetTriple: targetTriple,
                 shouldEnableDebuggingEntitlement:
-                    options.build.getTaskAllowEntitlement ?? (options.build.configuration == .debug)
+                    options.build.getTaskAllowEntitlement ?? (options.build.configuration == .debug),
+                omitFramePointers: options.build.omitFramePointers
             ),
             driverParameters: .init(
                 canRenameEntrypointFunctionName: driverSupport.checkSupportedFrontendFlags(

Sources/SPMBuildCore/BuildParameters/BuildParameters+Debugging.swift

@@ -18,20 +18,36 @@ extension BuildParameters {
         public init(
             debugInfoFormat: DebugInfoFormat = .dwarf,
             targetTriple: Triple,
-            shouldEnableDebuggingEntitlement: Bool
+            shouldEnableDebuggingEntitlement: Bool,
+            omitFramePointers: Bool?
         ) {
             self.debugInfoFormat = debugInfoFormat
 
             // Per rdar://112065568 for backtraces to work on macOS a special entitlement needs to be granted on the final
             // executable.
             self.shouldEnableDebuggingEntitlement = targetTriple.isMacOSX && shouldEnableDebuggingEntitlement
+            // rdar://117578677: frame-pointer to support backtraces
+            // this can be removed once the backtracer uses DWARF instead of frame pointers
+            if let omitFramePointers {
+                // if set, we respect user's preference
+                self.omitFramePointers = omitFramePointers
+            } else if targetTriple.isLinux() {
+                // on Linux we preserve frame pointers by default
+                self.omitFramePointers = false
+            } else {
+                // otherwise, use the platform default
+                self.omitFramePointers = nil
+            }
         }
 
         public var debugInfoFormat: DebugInfoFormat
 
         /// Whether the produced executable should be codesigned with the debugging entitlement, enabling enhanced
         /// backtraces on macOS.
         public var shouldEnableDebuggingEntitlement: Bool
+
+        /// Whether to omit frame pointers
+        public var omitFramePointers: Bool?
     }
 
     /// Represents the debugging strategy.

Sources/SPMBuildCore/BuildParameters/BuildParameters.swift

@@ -141,7 +141,8 @@ public struct BuildParameters: Encodable {
         let targetTriple = try targetTriple ?? .getHostTriple(usingSwiftCompiler: toolchain.swiftCompilerPath)
         self.debuggingParameters = debuggingParameters ?? .init(
             targetTriple: targetTriple,
-            shouldEnableDebuggingEntitlement: configuration == .debug
+            shouldEnableDebuggingEntitlement: configuration == .debug,
+            omitFramePointers: nil
         )
 
         self.dataPath = dataPath

Tests/BuildTests/BuildPlanTests.swift

@@ -1189,6 +1189,10 @@ final class BuildPlanTests: XCTestCase {
 #endif
 
         args += [hostTriple.isWindows() ? "-gdwarf" : "-g"]
+
+        if hostTriple.isLinux() {
+            args += ["-fno-omit-frame-pointer"]
+        }
 
         XCTAssertEqual(try ext.basicArguments(isCXX: false), args)
         XCTAssertEqual(try ext.objects, [buildPath.appending(components: "extlib.build", "extlib.c.o")])
@@ -1219,6 +1223,11 @@ final class BuildPlanTests: XCTestCase {
         args += ["-fmodules-cache-path=\(buildPath.appending(components: "ModuleCache"))"]
 #endif
         args += [hostTriple.isWindows() ? "-gdwarf" : "-g"]
+
+        if hostTriple.isLinux() {
+            args += ["-fno-omit-frame-pointer"]
+        }
+
         XCTAssertEqual(try exe.basicArguments(isCXX: false), args)
         XCTAssertEqual(try exe.objects, [buildPath.appending(components: "exe.build", "main.c.o")])
         XCTAssertEqual(exe.moduleMap, nil)
@@ -1514,6 +1523,11 @@ final class BuildPlanTests: XCTestCase {
         args += ["-fmodules-cache-path=\(buildPath.appending(components: "ModuleCache"))"]
 #endif
         args += [hostTriple.isWindows() ? "-gdwarf" : "-g"]
+
+        if hostTriple.isLinux() {
+            args += ["-fno-omit-frame-pointer"]
+        }
+
         XCTAssertEqual(try lib.basicArguments(isCXX: false), args)
         XCTAssertEqual(try lib.objects, [buildPath.appending(components: "lib.build", "lib.c.o")])
         XCTAssertEqual(lib.moduleMap, buildPath.appending(components: "lib.build", "module.modulemap"))
@@ -2509,6 +2523,11 @@ final class BuildPlanTests: XCTestCase {
 #endif
 
         expectedExeBasicArgs += [triple.isWindows() ? "-gdwarf" : "-g"]
+
+        if triple.isLinux() {
+            expectedExeBasicArgs += ["-fno-omit-frame-pointer"]
+        }
+
         XCTAssertEqual(try exe.basicArguments(isCXX: false), expectedExeBasicArgs)
         XCTAssertEqual(try exe.objects, [buildPath.appending(components: "exe.build", "main.c.o")])
         XCTAssertEqual(exe.moduleMap, nil)
@@ -2530,6 +2549,11 @@ final class BuildPlanTests: XCTestCase {
             triple.isWindows() ? "-gdwarf" : "-g",
             triple.isWindows() ? "-gdwarf" : "-g",
         ]
+
+        if triple.isLinux() {
+            expectedLibBasicArgs += ["-fno-omit-frame-pointer"]
+        }
+
         XCTAssertEqual(try lib.basicArguments(isCXX: true), expectedLibBasicArgs)
 
         XCTAssertEqual(try lib.objects, [buildPath.appending(components: "lib.build", "lib.cpp.o")])
@@ -3059,7 +3083,7 @@ final class BuildPlanTests: XCTestCase {
             "-fblocks", "-fmodules", "-fmodule-name=lib",
             "-I", Pkg.appending(components: "Sources", "lib", "include").pathString,
             "-fmodules-cache-path=\(buildPath.appending(components: "ModuleCache"))",
-            "-g",
+            "-g"
         ]
         XCTAssertEqual(try lib.basicArguments(isCXX: false), args)
         XCTAssertEqual(try lib.objects, [buildPath.appending(components: "lib.build", "lib.c.o")])
@@ -3136,7 +3160,10 @@ final class BuildPlanTests: XCTestCase {
 
         func createResult(for triple: Basics.Triple) throws -> BuildPlanResult {
             try BuildPlanResult(plan: BuildPlan(
-                buildParameters: mockBuildParameters(canRenameEntrypointFunctionName: true,     targetTriple: triple),
+                buildParameters: mockBuildParameters(
+                    canRenameEntrypointFunctionName: true,
+                    targetTriple: triple
+                ),
                 graph: graph,
                 fileSystem: fs,
                 observabilityScope: observability.topScope
@@ -3511,18 +3538,68 @@ final class BuildPlanTests: XCTestCase {
             XCTAssertMatch(dep, [.anySequence, "-DDEP", .anySequence])
 
             let cbar = try result.target(for: "cbar").clangTarget().basicArguments(isCXX: false)
-            XCTAssertMatch(cbar, [.anySequence, "-DCCC=2", "-I\(A.appending(components: "Sources", "cbar", "Sources", "headers"))", "-I\(A.appending(components: "Sources", "cbar", "Sources", "cppheaders"))", "-Icfoo", "-L", "cbar", "-Icxxfoo", "-L", "cxxbar", "-g", .end])
+            XCTAssertMatch(cbar, [.anySequence, "-DCCC=2", "-I\(A.appending(components: "Sources", "cbar", "Sources", "headers"))", "-I\(A.appending(components: "Sources", "cbar", "Sources", "cppheaders"))", "-Icfoo", "-L", "cbar", "-Icxxfoo", "-L", "cxxbar", "-g", "-fno-omit-frame-pointer", .end])
 
             let bar = try result.target(for: "bar").swiftTarget().compileArguments()
-            XCTAssertMatch(bar, [.anySequence, "-DLINUX", "-Isfoo", "-L", "sbar", "-cxx-interoperability-mode=default", "-enable-upcoming-feature", "BestFeature", "-g", "-Xcc", "-g", .end])
+            XCTAssertMatch(bar, [.anySequence, "-DLINUX", "-Isfoo", "-L", "sbar", "-cxx-interoperability-mode=default", "-enable-upcoming-feature", "BestFeature", "-g", "-Xcc", "-g", "-Xcc", "-fno-omit-frame-pointer", .end])
 
             let exe = try result.target(for: "exe").swiftTarget().compileArguments()
-            XCTAssertMatch(exe, [.anySequence, "-DFOO", "-g", "-Xcc", "-g", .end])
+            XCTAssertMatch(exe, [.anySequence, "-DFOO", "-g", "-Xcc", "-g", "-Xcc", "-fno-omit-frame-pointer", .end])
 
             let linkExe = try result.buildProduct(for: "exe").linkArguments()
             XCTAssertMatch(linkExe, [.anySequence, "-lsqlite3", "-llibz", "-Ilfoo", "-L", "lbar", "-g", .end])
         }
 
+        // omit frame pointers explicitly set to true
+        do {
+            let result = try BuildPlanResult(plan: BuildPlan(
+                buildParameters: mockBuildParameters(
+                    targetTriple: .x86_64Linux,
+                    omitFramePointers: true
+                ),
+                graph: graph,
+                fileSystem: fs,
+                observabilityScope: observability.topScope
+            ))
+
+            let dep = try result.target(for: "t1").swiftTarget().compileArguments()
+            XCTAssertMatch(dep, [.anySequence, "-DDEP", .anySequence])
+
+            let cbar = try result.target(for: "cbar").clangTarget().basicArguments(isCXX: false)
+            XCTAssertMatch(cbar, [.anySequence, "-DCCC=2", "-I\(A.appending(components: "Sources", "cbar", "Sources", "headers"))", "-I\(A.appending(components: "Sources", "cbar", "Sources", "cppheaders"))", "-Icfoo", "-L", "cbar", "-Icxxfoo", "-L", "cxxbar", "-g", "-fomit-frame-pointer", .end])
+
+            let bar = try result.target(for: "bar").swiftTarget().compileArguments()
+            XCTAssertMatch(bar, [.anySequence, "-DLINUX", "-Isfoo", "-L", "sbar", "-cxx-interoperability-mode=default", "-enable-upcoming-feature", "BestFeature", "-g", "-Xcc", "-g", "-Xcc", "-fomit-frame-pointer", .end])
+
+            let exe = try result.target(for: "exe").swiftTarget().compileArguments()
+            XCTAssertMatch(exe, [.anySequence, "-DFOO", "-g", "-Xcc", "-g", "-Xcc", "-fomit-frame-pointer", .end])
+        }
+
+        // omit frame pointers explicitly set to false
+        do {
+            let result = try BuildPlanResult(plan: BuildPlan(
+                buildParameters: mockBuildParameters(
+                    targetTriple: .x86_64Linux,
+                    omitFramePointers: false
+                ),
+                graph: graph,
+                fileSystem: fs,
+                observabilityScope: observability.topScope
+            ))
+
+            let dep = try result.target(for: "t1").swiftTarget().compileArguments()
+            XCTAssertMatch(dep, [.anySequence, "-DDEP", .anySequence])
+
+            let cbar = try result.target(for: "cbar").clangTarget().basicArguments(isCXX: false)
+            XCTAssertMatch(cbar, [.anySequence, "-DCCC=2", "-I\(A.appending(components: "Sources", "cbar", "Sources", "headers"))", "-I\(A.appending(components: "Sources", "cbar", "Sources", "cppheaders"))", "-Icfoo", "-L", "cbar", "-Icxxfoo", "-L", "cxxbar", "-g", "-fno-omit-frame-pointer", .end])
+
+            let bar = try result.target(for: "bar").swiftTarget().compileArguments()
+            XCTAssertMatch(bar, [.anySequence, "-DLINUX", "-Isfoo", "-L", "sbar", "-cxx-interoperability-mode=default", "-enable-upcoming-feature", "BestFeature", "-g", "-Xcc", "-g", "-Xcc", "-fno-omit-frame-pointer", .end])
+
+            let exe = try result.target(for: "exe").swiftTarget().compileArguments()
+            XCTAssertMatch(exe, [.anySequence, "-DFOO", "-g", "-Xcc", "-g", "-Xcc", "-fno-omit-frame-pointer", .end])
+        }
+
         do {
             let result = try createResult(for: .x86_64MacOS)
 

Tests/BuildTests/MockBuildTestHelper.swift

@@ -78,7 +78,8 @@ func mockBuildParameters(
     indexStoreMode: BuildParameters.IndexStoreMode = .off,
     useExplicitModuleBuild: Bool = false,
     linkerDeadStrip: Bool = true,
-    linkTimeOptimizationMode: BuildParameters.LinkTimeOptimizationMode? = nil
+    linkTimeOptimizationMode: BuildParameters.LinkTimeOptimizationMode? = nil,
+    omitFramePointers: Bool? = nil
 ) -> BuildParameters {
     return try! BuildParameters(
         dataPath: buildPath,
@@ -90,6 +91,11 @@ func mockBuildParameters(
         pkgConfigDirectories: [],
         workers: 3,
         indexStoreMode: indexStoreMode,
+        debuggingParameters: .init(
+            targetTriple: targetTriple,
+            shouldEnableDebuggingEntitlement: config == .debug,
+            omitFramePointers: omitFramePointers
+        ),
         driverParameters: .init(
             canRenameEntrypointFunctionName: canRenameEntrypointFunctionName,
             useExplicitModuleBuild: useExplicitModuleBuild