First commit

bkhouri · bkhouri · commit fe70b3a1fc98 · 2025-11-25T19:48:08.000Z
diff --git a/Sources/SWBCore/SpecImplementations/Tools/LinkerTools.swift b/Sources/SWBCore/SpecImplementations/Tools/LinkerTools.swift
@@ -368,7 +368,7 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec
             && cbc.producer.platform?.minimumOSForSwiftInTheOS != nil {
             // NOTE: For swift.org toolchains, this is fine as `DYLD_LIBRARY_PATH` is used to override these settings.
             let swiftABIVersion =  await (cbc.producer.swiftCompilerSpec.discoveredCommandLineToolSpecInfo(cbc.producer, cbc.scope, delegate) as? DiscoveredSwiftCompilerToolSpecInfo)?.swiftABIVersion
-            runpathSearchPaths.insert( swiftABIVersion.flatMap { "/usr/lib/swift-\($0)" } ?? "/usr/lib/swift", at: 0)
+            runpathSearchPaths.insert( swiftABIVersion.flatMap { "/usr/lib/swift-\($0)" } ?? "/usr/lib/swift_static", at: 0)
             // Ensure the linker driver does not insert a duplicate rpath (if linking using swiftc)
             suppressDriverStdlibPaths = true
         }
diff --git a/Sources/SWBCore/SpecImplementations/Tools/SwiftCompiler.swift b/Sources/SWBCore/SpecImplementations/Tools/SwiftCompiler.swift
@@ -2961,8 +2961,10 @@ public final class SwiftCompilerSpec : CompilerSpec, SpecIdentifierType, SwiftDi
         // NOTE: With Swift in the OS, static libs aren't being supplied by the toolchains
         //       so users of this flag will need to provide their own.
         if scope.evaluate(BuiltinMacros.SWIFT_FORCE_STATIC_LINK_STDLIB, lookup: lookup) {
+            print("staticallyLinkSwiftStdlib: true")
             return true
         }
+        print("staticallyLinkSwiftStdlib: false")
         return false
     }
 
@@ -3001,19 +3003,24 @@ public final class SwiftCompilerSpec : CompilerSpec, SpecIdentifierType, SwiftDi
         if swiftLibraryPath.isEmpty {
             // Look next to the compiler and in the toolchains for one.
             if shouldStaticLinkStdlib {
+                print("Finding static lib search paths")
                 swiftLibraryPath = findSearchPathForLibrary(executablePath: swiftc, possibleNames: [
                         "swift_static/\(platformName)/lib\(swiftStdlibName).a",
                         "swift_static/lib\(swiftStdlibName).a",
                         "lib\(swiftStdlibName).a",
                     ], toolchains: producer.toolchains) ?? Path("")
             } else {
+                print("Finding dynamiclib search paths")
                 swiftLibraryPath = findSearchPathForLibrary(executablePath: swiftc, possibleNames: [
                         "swift/\(platformName)/lib\(swiftStdlibName).\(dynamicLibraryExtension)",
                         "swift/lib\(swiftStdlibName).\(dynamicLibraryExtension)",
                         "lib\(swiftStdlibName).\(dynamicLibraryExtension)",
                     ], toolchains: producer.toolchains) ?? Path("")
             }
+        } else {
+            print("swiftLibraryPath is not empty.")
         }
+        print("********** swiftLibraryPath are: \(swiftLibraryPath)")
 
         let isMacCatalystUnzippered = producer.sdkVariant?.isMacCatalyst == true && !scope.evaluate(BuiltinMacros.IS_ZIPPERED, lookup: lookup)
 
@@ -3023,12 +3030,12 @@ public final class SwiftCompilerSpec : CompilerSpec, SpecIdentifierType, SwiftDi
             // TAPI requires absolute paths.
             let sdkroot = scope.evaluate(BuiltinMacros.SDKROOT, lookup: lookup)
             if !sdkroot.isEmpty {
-                sdkPathArgument = ["-L" + sdkroot.join("usr/lib/swift").str]
+                sdkPathArgument = ["-L" + sdkroot.join("usr/lib/swift_static").str]
                 unzipperedSDKPathArgument = ["-L" + sdkroot.join("System/iOSSupport/usr/lib/swift").str]
             }
         } else {
             // ld prefers SDK relative paths.
-            sdkPathArgument = ["-L/usr/lib/swift"]
+            sdkPathArgument = ["-L/usr/lib/swift_static"]
             unzipperedSDKPathArgument = ["-L/System/iOSSupport/usr/lib/swift"]
         }
 
@@ -3039,6 +3046,7 @@ public final class SwiftCompilerSpec : CompilerSpec, SpecIdentifierType, SwiftDi
             }
 
             args += [sdkPathArgument]
+            print("**** SDK Parth arguments: \(sdkPathArgument)")
         }
 
         // Add the -L to the standard library path. This is used primarily for the OSS toolchain now as each of the libs have been moved into the Swift SDK.
@@ -3061,9 +3069,20 @@ public final class SwiftCompilerSpec : CompilerSpec, SpecIdentifierType, SwiftDi
 
         if !forTAPI {
             if shouldStaticLinkStdlib {
-                args += [["-Xlinker", "-force_load_swift_libs"]]
-                // The Swift runtime requires libc++ & Foundation.
-                args += [["-lc++", "-framework", "Foundation"]]
+                // Platform-specific static linking flags
+                // args += [["-Xlinker", "$(LD_FORCE_STATIC_LINK_STDLIB)"]]
+                if producer.isApplePlatform {
+                    // Darwin/Apple platforms use force_load_swift_libs and Framework linking
+                    args += [["-Xlinker", "-force_load_swift_libs"]]
+                    args += [["-lc++", "-framework", "Foundation"]]
+                } else {
+                    // Non-Apple platforms (Linux, etc.) use static library linking
+                    // args += [["-lc++", "-framework", "Foundation"]]
+                    // args += [["-lc++"]]
+                    args += [["-static-stdlib"]]
+                    // args += [["-Xlinker", "-no-pie"]]
+                    // Note: Foundation is not available as a framework on non-Apple platforms
+                }
             }
 
             // Add the AST, if debugging.
diff --git a/Sources/SWBTaskExecution/TaskActions/EmbedSwiftStdLibTaskAction.swift b/Sources/SWBTaskExecution/TaskActions/EmbedSwiftStdLibTaskAction.swift
@@ -27,7 +27,7 @@ fileprivate extension MachO {
             .flatMap { try $0.linkedLibraryPaths() }
             .compactMap { (lib: String) -> String? in
                 let pcs = Path(lib)
-                if (pcs.dirname.str == "@rpath" || pcs.dirname == Path("/usr/lib/swift")) && executableFileNameMatchesSwiftRuntimeLibPattern(pcs.basename) {
+                if (pcs.dirname.str == "@rpath" || pcs.dirname == Path("/usr/lib/swift_static")) && executableFileNameMatchesSwiftRuntimeLibPattern(pcs.basename) {
                     return pcs.basename
                 }
                 else {
diff --git a/Sources/SWBUniversalPlatform/Specs/Clang.xcspec b/Sources/SWBUniversalPlatform/Specs/Clang.xcspec
@@ -323,6 +323,22 @@
                 );
                 Category = LanguageObjC;
             },
+            {
+                Name = "CLANG_FORCE_STATIC_LINK_STDLIB";
+                Type = Boolean;
+                DefaultValue = "$(SWIFT_FORCE_STATIC_LINK_STDLIB)";
+                CommandLineArgs = {
+                    YES = ();
+                    NO = ();
+                };
+                // This option is passed for linking to inform the compiler
+                // that the ObjC runtime must be linked in (with possible
+                // backwards compatibility libraries linked in).
+                AdditionalLinkerArgs = {
+                    YES = ( "$(LD_FORCE_STATIC_LINK_STDLIB)" );
+                    NO = ();
+                };
+            },
             {
                 Name = "CLANG_USE_RESPONSE_FILE";
                 Type = Boolean;
diff --git a/Sources/SWBUniversalPlatform/Specs/Ld.xcspec b/Sources/SWBUniversalPlatform/Specs/Ld.xcspec
@@ -157,6 +157,18 @@
                 Name = LD_OBJC_RUNTIME_ARGS_swiftc;
                 DefaultValue = "-link-objc-runtime";
             },
+            {
+                Name = LD_FORCE_STATIC_LINK_STDLIB;
+                DefaultValue = "$(LD_STATIC_LINK_ARGS$(LINKER_DRIVER))";
+            },
+            {
+                Name = LD_FORCE_STATIC_LINK_STDLIB_clang;
+                DefaultValue = "-static";
+            },
+            {
+                Name = LD_FORCE_STATIC_LINK_STDLIB_swiftc;
+                DefaultValue = "-force_load_swift_libs";
+            },
             {
                 Name = CLANG_SDKROOT_LINKER_INPUT;
                 Type = Path;
diff --git a/Sources/SWBUniversalPlatform/Specs/Swift.xcspec b/Sources/SWBUniversalPlatform/Specs/Swift.xcspec
@@ -1119,7 +1119,22 @@
                     NO = ();
                 };
             },
-
+            {
+                Name = "SWIFT_FORCE_STATIC_LINK_STDLIB";
+                Type = Boolean;
+                DefaultValue = "$(SWIFT_FORCE_STATIC_LINK_STDLIB)";
+                CommandLineArgs = {
+                    YES = ();
+                    NO = ();
+                };
+                // This option is passed for linking to inform the compiler
+                // that the ObjC runtime must be linked in (with possible
+                // backwards compatibility libraries linked in).
+                AdditionalLinkerArgs = {
+                    YES = ( "$(LD_FORCE_STATIC_LINK_STDLIB)" );
+                    NO = ();
+                };
+            },
             {
                 Name = "CLANG_COVERAGE_MAPPING";
                 Type = Boolean;
diff --git a/Tests/SWBCoreTests/SwiftCompilerTests.swift b/Tests/SWBCoreTests/SwiftCompilerTests.swift
@@ -117,7 +117,7 @@ fileprivate final class TestSwiftParserDelegate: TaskOutputParserDelegate, Senda
     }
 
     /// Check the standard library linking options.
-    @Test(.requireHostOS(.macOS))
+    @Test
     func standardLibraryLinking() async throws {
         let core = try await getCore()
 
@@ -145,7 +145,7 @@ fileprivate final class TestSwiftParserDelegate: TaskOutputParserDelegate, Senda
             try await #expect(spec.computeAdditionalLinkerArgs(producer, scope: scope, lookup: { _ in nil }, inputFileTypes: [], optionContext: optionContext, delegate: CapturingTaskGenerationDelegate(producer: producer, userPreferences: .defaultForTesting)).args == additionalSwiftLinkerArgs(spec, producer, scope, stdlibPath))
         }
 
-        // Check force static stdlib.
+        // Check force static stdlib on Apple platforms (macOS).
         do {
             let producer = try MockCommandProducer(core: core, productTypeIdentifier: "com.apple.product-type.framework", platform: "macosx")
             let stdlibPath = swiftcPath.dirname.dirname.join("lib/swift_static/fakeos")
@@ -157,9 +157,26 @@ fileprivate final class TestSwiftParserDelegate: TaskOutputParserDelegate, Senda
             let scope = MacroEvaluationScope(table: table)
             let delegate = TestTaskPlanningDelegate(clientDelegate: MockTestTaskPlanningClientDelegate(), fs: localFS)
             let optionContext = await spec.discoveredCommandLineToolSpecInfo(producer, scope, delegate)
+            // On Apple platforms, should use Apple-specific static linking flags
             try await #expect(spec.computeAdditionalLinkerArgs(producer, scope: scope, lookup: { _ in nil }, inputFileTypes: [], optionContext: optionContext, delegate: CapturingTaskGenerationDelegate(producer: producer, userPreferences: .defaultForTesting)).args == (additionalSwiftLinkerArgs(spec, producer, scope, stdlibPath)) + [["-Xlinker", "-force_load_swift_libs"], ["-lc++", "-framework", "Foundation"]])
         }
 
+        // Check force static stdlib on non-Apple platforms (Linux).
+        do {
+            let producer = try MockCommandProducer(core: core, productTypeIdentifier: "com.apple.product-type.framework", platform: "linux")
+            let stdlibPath = swiftcPath.dirname.dirname.join("lib/swift_static/linux")
+            var table = MacroValueAssignmentTable(namespace: core.specRegistry.internalMacroNamespace)
+            table.push(BuiltinMacros.SWIFT_EXEC, literal: swiftcPath.str)
+            table.push(BuiltinMacros.SWIFT_STDLIB, literal: "swiftCore")
+            table.push(BuiltinMacros.PLATFORM_NAME, literal: "linux")
+            table.push(BuiltinMacros.SWIFT_FORCE_STATIC_LINK_STDLIB, literal: true)
+            let scope = MacroEvaluationScope(table: table)
+            let delegate = TestTaskPlanningDelegate(clientDelegate: MockTestTaskPlanningClientDelegate(), fs: localFS)
+            let optionContext = await spec.discoveredCommandLineToolSpecInfo(producer, scope, delegate)
+            // On non-Apple platforms, should use standard static linking flags (no Darwin-specific flags)
+            try await #expect(spec.computeAdditionalLinkerArgs(producer, scope: scope, lookup: { _ in nil }, inputFileTypes: [], optionContext: optionContext, delegate: CapturingTaskGenerationDelegate(producer: producer, userPreferences: .defaultForTesting)).args == (additionalSwiftLinkerArgs(spec, producer, scope, stdlibPath)) + [["-lc++"]])
+        }
+
         // Check tool product type.
         do {
             let producer = try MockCommandProducer(core: core, productTypeIdentifier: "com.apple.product-type.tool", platform: "macosx", toolchain: core.toolchainRegistry.defaultToolchain)

Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,7 @@ public final class LdLinkerSpec : GenericLinkerSpec, SpecIdentifierType, @unchec`
`368`	`368`	`&& cbc.producer.platform?.minimumOSForSwiftInTheOS != nil {`
`369`	`369`	// NOTE: For swift.org toolchains, this is fine as `DYLD_LIBRARY_PATH` is used to override these settings.
`370`	`370`	`let swiftABIVersion = await (cbc.producer.swiftCompilerSpec.discoveredCommandLineToolSpecInfo(cbc.producer, cbc.scope, delegate) as? DiscoveredSwiftCompilerToolSpecInfo)?.swiftABIVersion`
`371`		`- runpathSearchPaths.insert( swiftABIVersion.flatMap { "/usr/lib/swift-\($0)" } ?? "/usr/lib/swift", at: 0)`
	`371`	`+ runpathSearchPaths.insert( swiftABIVersion.flatMap { "/usr/lib/swift-\($0)" } ?? "/usr/lib/swift_static", at: 0)`
`372`	`372`	`// Ensure the linker driver does not insert a duplicate rpath (if linking using swiftc)`
`373`	`373`	`suppressDriverStdlibPaths = true`
`374`	`374`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ fileprivate extension MachO {`
`27`	`27`	`.flatMap { try $0.linkedLibraryPaths() }`
`28`	`28`	`.compactMap { (lib: String) -> String? in`
`29`	`29`	`let pcs = Path(lib)`
`30`		`- if (pcs.dirname.str == "@rpath" \|\| pcs.dirname == Path("/usr/lib/swift")) && executableFileNameMatchesSwiftRuntimeLibPattern(pcs.basename) {`
	`30`	`+ if (pcs.dirname.str == "@rpath" \|\| pcs.dirname == Path("/usr/lib/swift_static")) && executableFileNameMatchesSwiftRuntimeLibPattern(pcs.basename) {`
`31`	`31`	`return pcs.basename`
`32`	`32`	`}`
`33`	`33`	`else {`