commit 809f7d037c8c3a773b9f83df2fbeeef66bf00548 · pyrox.dev/nixpkgs

+26 -13

pkgs/development/compilers/swift/compiler/default.nix

···

       111
       111
        
           "swift-remote-mirror-headers"

     

       112
       112
        
         ];

     

       113
       113
        
       

     

       114
       114
       +
         clangForWrappers = clang.override (prev: {

     

       115
       115
       +
           extraBuildCommands =

     

       116
       116
       +
             prev.extraBuildCommands

     

       117
       117
       +
             # We need to use the resource directory corresponding to Swift’s

     

       118
       118
       +
             # version of Clang instead of passing along the one from the

     

       119
       119
       +
             # `cc-wrapper` flags.

     

       120
       120
       +
             + ''

     

       121
       121
       +
               substituteInPlace $out/nix-support/cc-cflags \

     

       122
       122
       +
                 --replace-fail " -resource-dir=$out/resource-root" ""

     

       123
       123
       +
             '';

     

       124
       124
       +
         });

     

       125
       125
       +
       

     

       114
       126
        
         # Build a tool used during the build to create a custom clang wrapper, with

     

       115
       127
        
         # which we wrap the clang produced by the swift build.

     

       116
       128
        
         #

     
···

       130
       142
        
           unwrappedClang="$targetFile-unwrapped"

     

       131
       143
        
       

     

       132
       144
        
           mv "$targetFile" "$unwrappedClang"

     

       133
       133
       -
           sed < '${clang}/bin/clang' > "$targetFile" \

     

       145
       145
       +
           sed < '${clangForWrappers}/bin/clang' > "$targetFile" \

     

       134
       146
        
             -e 's|^\s*exec|exec -a "$0"|g' \

     

       135
       147
        
             -e 's|^\[\[ "${clang.cc}/bin/clang" = \*++ ]]|[[ "$0" = *++ ]]|' \

     

       136
       148
        
             -e "s|${clang.cc}/bin/clang|$unwrappedClang|g" \

     
···

       146
       158
        
         # executable uses $0 to detect what tool is called.

     

       147
       159
        
         wrapperParams = {

     

       148
       160
        
           inherit bintools;

     

       149
       149
       -
           default_cc_wrapper = clang; # Instead of `@out@` in the original.

     

       150
       161
        
           coreutils_bin = lib.getBin coreutils;

     

       151
       162
        
           gnugrep_bin = gnugrep;

     

       152
       163
        
           suffixSalt = lib.replaceStrings [ "-" "." ] [ "_" "_" ] targetPlatform.config;

     

       153
       164
        
           use_response_file_by_default = 1;

     

       154
       165
        
           swiftDriver = "";

     

       155
       155
       -
           # NOTE: @prog@ needs to be filled elsewhere.

     

       166
       166
       +
           # NOTE: @cc_wrapper@ and @prog@ need to be filled elsewhere.

     

       156
       167
        
         };

     

       157
       168
        
         swiftWrapper = runCommand "swift-wrapper.sh" wrapperParams ''

     

       158
       169
        
           # Make empty to avoid adding the SDK’s modules in the bootstrap wrapper. Otherwise, the SDK conflicts with the

     
···

       168
       179
        
           mv "$targetFile" "$unwrappedSwift"

     

       169
       180
        
           sed < '${swiftWrapper}' > "$targetFile" \

     

       170
       181
        
             -e "s|@prog@|'$unwrappedSwift'|g" \

     

       182
       182
       +
             -e 's|@cc_wrapper@|${clangForWrappers}|g' \

     

       171
       183
        
             -e 's|exec "$prog"|exec -a "$0" "$prog"|g'

     

       172
       184
        
           chmod a+x "$targetFile"

     

       173
       185
        
         '';

     
···

       308
       320
        
       

     

       309
       321
        
            patch -p1 -d swift -i ${./patches/swift-cmake-3.25-compat.patch}

     

       310
       322
        
            patch -p1 -d swift -i ${./patches/swift-wrap.patch}

     

       311
       311
       -
            patch -p1 -d swift -i ${./patches/swift-nix-resource-root.patch}

     

       312
       323
        
            patch -p1 -d swift -i ${./patches/swift-linux-fix-libc-paths.patch}

     

       313
       313
       -
            patch -p1 -d swift -i ${./patches/swift-linux-fix-linking.patch}

     

       324
       324
       +
            patch -p1 -d swift -i ${

     

       325
       325
       +
              replaceVars ./patches/swift-linux-fix-linking.patch {

     

       326
       326
       +
                inherit clang;

     

       327
       327
       +
              }

     

       328
       328
       +
            }

     

       314
       329
        
            patch -p1 -d swift -i ${./patches/swift-darwin-libcxx-flags.patch}

     

       315
       330
        
            patch -p1 -d swift -i ${

     

       316
       331
        
              replaceVars ./patches/swift-darwin-plistbuddy-workaround.patch {

     
···

       506
       521
        
             }

     

       507
       522
        
           "

     

       508
       523
        
           buildProject llvm llvm-project/llvm

     

       524
       524
       +
       

     

       525
       525
       +
           # Ensure that the built Clang can find the runtime libraries by

     

       526
       526
       +
           # copying the symlinks from the main wrapper.

     

       527
       527
       +
           cp -P ${clang}/resource-root/{lib,share} $SWIFT_BUILD_ROOT/llvm/lib/clang/15.0.0/

     

       509
       528
        
       

     

       510
       529
        
         ''

     

       511
       530
        
         + lib.optionalString stdenv.hostPlatform.isDarwin ''

     
···

       714
       733
        
           ln -s $lib/lib/swift $out/lib/swift

     

       715
       734
        
       

     

       716
       735
        
           # Swift has a separate resource root from Clang, but locates the Clang

     

       717
       717
       -
           # resource root via subdir or symlink. Provide a default here, but we also

     

       718
       718
       -
           # patch Swift to prefer NIX_CC if set.

     

       719
       719
       -
           #

     

       720
       720
       -
           # NOTE: We don't symlink directly here, because that'd add a run-time dep

     

       721
       721
       -
           # on the full Clang compiler to every Swift executable. The copy here is

     

       722
       722
       -
           # just copying the 3 symlinks inside to smaller closures.

     

       723
       723
       -
           mkdir $lib/lib/swift/clang

     

       724
       724
       -
           cp -P ${clang}/resource-root/* $lib/lib/swift/clang/

     

       736
       736
       +
           # resource root via subdir or symlink.

     

       737
       737
       +
           mv $SWIFT_BUILD_ROOT/llvm/lib/clang/15.0.0 $lib/lib/swift/clang

     

       725
       738
        
         '';

     

       726
       739
        
       

     

       727
       740
        
         preFixup = lib.optionalString stdenv.hostPlatform.isLinux ''

+11 -15

pkgs/development/compilers/swift/compiler/patches/swift-linux-fix-linking.patch

···

       1
       1
       +
       diff --git a/lib/Driver/ToolChains.cpp b/lib/Driver/ToolChains.cpp

     

       2
       2
       +
       index c0ee9217e8..bf7737d6fa 100644

     

       1
       3
        
       --- a/lib/Driver/ToolChains.cpp

     

       2
       4
        
       +++ b/lib/Driver/ToolChains.cpp

     

       3
       3
       -
       @@ -1475,7 +1475,17 @@ const char *ToolChain::getClangLinkerDriver(

     

       5
       5
       +
       @@ -1489,6 +1489,12 @@

     

       6
       6
       +
              LinkerDriver = Args.MakeArgString(tool.get());

     

       7
       7
       +
          }

     

       4
       8
        
        

     

       5
       5
       -
            // If there is a linker driver in the toolchain folder, use that instead.

     

       6
       6
       -
            if (auto tool = llvm::sys::findProgramByName(LinkerDriver, {toolchainPath}))

     

       7
       7
       -
       -      LinkerDriver = Args.MakeArgString(tool.get());

     

       8
       8
       -
       +      return Args.MakeArgString(tool.get());

     

       9
       9
       -
       +  }

     

       10
       10
       -
       +

     

       11
       11
       -
       +  // For Nix, prefer linking using the wrapped system clang, instead of using

     

       9
       9
       +
       +  // For Nix, prefer linking using the wrapped Nixpkgs clang, instead of using

     

       12
       10
        
       +  // the unwrapped clang packaged with swift. The latter is unable to link, but

     

       13
       11
        
       +  // we still want to use it for other purposes (clang importer).

     

       14
       14
       -
       +  if (auto nixCC = llvm::sys::Process::GetEnv("NIX_CC")) {

     

       15
       15
       -
       +    llvm::SmallString<128> binDir(nixCC.getValue());

     

       16
       16
       -
       +    llvm::sys::path::append(binDir, "bin");

     

       17
       17
       -
       +    if (auto tool = llvm::sys::findProgramByName(LinkerDriver, {binDir.str()}))

     

       18
       18
       -
       +      return Args.MakeArgString(tool.get());

     

       19
       19
       -
          }

     

       12
       12
       +
       +  if (auto tool = llvm::sys::findProgramByName(LinkerDriver, {"@clang@/bin"}))

     

       13
       13
       +
       +    return Args.MakeArgString(tool.get());

     

       14
       14
       +
       +

     

       15
       15
       +
          return LinkerDriver;

     

       16
       16
       +
        }

     

       20
       17
        
        

     

       21
       21
       -
          return LinkerDriver;

-67

pkgs/development/compilers/swift/compiler/patches/swift-nix-resource-root.patch

···

       1
       1
       -
       Swift normally looks for the Clang resource dir in a subdir/symlink of its own

     

       2
       2
       -
       resource dir. We provide a symlink to the Swift build-time Clang as a default

     

       3
       3
       -
       there, but we also here patch two checks to try locate it via NIX_CC.

     

       4
       4
       -
       

     

       5
       5
       -
       The first (ClangImporter.cpp) happens when Swift code imports C modules. The

     

       6
       6
       -
       second (ToolChains.cpp) happens when Swift is used to link the final product.

     

       7
       7
       -
       

     

       8
       8
       -
       --- a/lib/ClangImporter/ClangImporter.cpp

     

       9
       9
       -
       +++ b/lib/ClangImporter/ClangImporter.cpp

     

       10
       10
       -
       @@ -73,6 +73,7 @@

     

       11
       11
       -
        #include "llvm/Support/FileSystem.h"

     

       12
       12
       -
        #include "llvm/Support/Memory.h"

     

       13
       13
       -
        #include "llvm/Support/Path.h"

     

       14
       14
       -
       +#include "llvm/Support/Process.h"

     

       15
       15
       -
        #include "llvm/Support/VirtualFileSystem.h"

     

       16
       16
       -
        #include "llvm/Support/YAMLParser.h"

     

       17
       17
       -
        #include <algorithm>

     

       18
       18
       -
       @@ -786,6 +787,17 @@ importer::addCommonInvocationArguments(

     

       19
       19
       -
        

     

       20
       20
       -
          const std::string &overrideResourceDir = importerOpts.OverrideResourceDir;

     

       21
       21
       -
          if (overrideResourceDir.empty()) {

     

       22
       22
       -
       +    // Prefer the Clang resource directory from NIX_CC, to allow swapping in a

     

       23
       23
       -
       +    // different stdenv.

     

       24
       24
       -
       +    // TODO: Figure out how to provide a user override for this. Probably a

     

       25
       25
       -
       +    // niche use case, though, and for now a user can unset NIX_CC to work

     

       26
       26
       -
       +    // around it if necessary.

     

       27
       27
       -
       +    if (auto nixCC = llvm::sys::Process::GetEnv("NIX_CC")) {

     

       28
       28
       -
       +      llvm::SmallString<128> resourceDir(nixCC.getValue());

     

       29
       29
       -
       +      llvm::sys::path::append(resourceDir, "resource-root");

     

       30
       30
       -
       +      invocationArgStrs.push_back("-resource-dir");

     

       31
       31
       -
       +      invocationArgStrs.push_back(std::string(resourceDir.str()));

     

       32
       32
       -
       +    } else {

     

       33
       33
       -
            llvm::SmallString<128> resourceDir(searchPathOpts.RuntimeResourcePath);

     

       34
       34
       -
        

     

       35
       35
       -
            // Adjust the path to refer to our copy of the Clang resource directory

     

       36
       36
       -
       @@ -801,6 +813,7 @@ importer::addCommonInvocationArguments(

     

       37
       37
       -
            // Set the Clang resource directory to the path we computed.

     

       38
       38
       -
            invocationArgStrs.push_back("-resource-dir");

     

       39
       39
       -
            invocationArgStrs.push_back(std::string(resourceDir.str()));

     

       40
       40
       -
       +    } // nixCC

     

       41
       41
       -
          } else {

     

       42
       42
       -
            invocationArgStrs.push_back("-resource-dir");

     

       43
       43
       -
            invocationArgStrs.push_back(overrideResourceDir);

     

       44
       44
       -
       --- a/lib/Driver/ToolChains.cpp

     

       45
       45
       -
       +++ b/lib/Driver/ToolChains.cpp

     

       46
       46
       -
       @@ -1393,10 +1393,20 @@ void ToolChain::getClangLibraryPath(const ArgList &Args,

     

       47
       47
       -
                                            SmallString<128> &LibPath) const {

     

       48
       48
       -
          const llvm::Triple &T = getTriple();

     

       49
       49
       -
        

     

       50
       50
       -
       +  // Nix: We provide a `clang` symlink in the default Swift resource root, but

     

       51
       51
       -
       +  // prefer detecting the Clang resource root via NIX_CC, to allow swapping in

     

       52
       52
       -
       +  // a different stdenv. However, always honor a user-provided `-resource-dir`.

     

       53
       53
       -
       +  auto nixCC = llvm::sys::Process::GetEnv("NIX_CC");

     

       54
       54
       -
       +  if (nixCC && !Args.hasArgNoClaim(options::OPT_resource_dir)) {

     

       55
       55
       -
       +    LibPath.assign(nixCC.getValue());

     

       56
       56
       -
       +    llvm::sys::path::append(LibPath, "resource-root");

     

       57
       57
       -
       +  } else {

     

       58
       58
       -
          getResourceDirPath(LibPath, Args, /*Shared=*/true);

     

       59
       59
       -
          // Remove platform name.

     

       60
       60
       -
          llvm::sys::path::remove_filename(LibPath);

     

       61
       61
       -
       -  llvm::sys::path::append(LibPath, "clang", "lib",

     

       62
       62
       -
       +  llvm::sys::path::append(LibPath, "clang");

     

       63
       63
       -
       +  } // nixCC

     

       64
       64
       -
       +  llvm::sys::path::append(LibPath, "lib",

     

       65
       65
       -
                                  T.isOSDarwin() ? "darwin"

     

       66
       66
       -
                                                 : getPlatformNameForTriple(T));

     

       67
       67
       -
        }

+4 -2

pkgs/development/compilers/swift/swift-driver/default.nix

···

       10
       10
        
         XCTest,

     

       11
       11
        
         sqlite,

     

       12
       12
        
         ncurses,

     

       13
       13
       +
         clang,

     

       13
       14
        
         replaceVars,

     

       14
       15
        
       }:

     

       15
       16
        
       let

     
···

       40
       41
        
         ];

     

       41
       42
        
       

     

       42
       43
        
         patches = [

     

       43
       43
       -
           ./patches/nix-resource-root.patch

     

       44
       44
        
           ./patches/disable-catalyst.patch

     

       45
       45
       -
           ./patches/linux-fix-linking.patch

     

       45
       45
       +
           (replaceVars ./patches/linux-fix-linking.patch {

     

       46
       46
       +
             inherit clang;

     

       47
       47
       +
           })

     

       46
       48
        
           # TODO: Replace with branch patch once merged:

     

       47
       49
        
           # https://github.com/apple/swift-driver/pull/1197

     

       48
       50
        
           (fetchpatch {

+7 -7

pkgs/development/compilers/swift/swift-driver/patches/linux-fix-linking.patch

···

       1
       1
       +
       diff --git a/Sources/SwiftDriver/Jobs/GenericUnixToolchain+LinkerSupport.swift b/Sources/SwiftDriver/Jobs/GenericUnixToolchain+LinkerSupport.swift

     

       2
       2
       +
       index a4a735f498..381522cc1f 100644

     

       1
       3
        
       --- a/Sources/SwiftDriver/Jobs/GenericUnixToolchain+LinkerSupport.swift

     

       2
       4
        
       +++ b/Sources/SwiftDriver/Jobs/GenericUnixToolchain+LinkerSupport.swift

     

       3
       5
        
       @@ -10,6 +10,7 @@

     
···

       8
       10
        
        import SwiftOptions

     

       9
       11
        
        

     

       10
       12
        
        import func TSCBasic.lookupExecutablePath

     

       11
       11
       -
       @@ -120,7 +121,20 @@ extension GenericUnixToolchain {

     

       13
       13
       +
       @@ -120,7 +121,18 @@

     

       12
       14
        
              // just using `clang` and avoid a dependency on the C++ runtime.

     

       13
       15
        
              let clangTool: Tool =

     

       14
       16
        
                parsedOptions.hasArgument(.enableExperimentalCxxInterop) ? .clangxx : .clang

     

       15
       17
        
       -      var clangPath = try getToolPath(clangTool)

     

       16
       18
        
       +

     

       17
       17
       -
       +      // For Nix, prefer linking using the wrapped system clang, instead of using

     

       19
       19
       +
       +      // For Nix, prefer linking using the wrapped Nixpkgs clang, instead of using

     

       18
       20
        
       +      // the unwrapped clang packaged with swift. The latter is unable to link, but

     

       19
       21
        
       +      // we still want to use it for other purposes (clang importer).

     

       20
       22
        
       +      var clangPath: AbsolutePath

     

       21
       21
       -
       +      let env = ProcessInfo.processInfo.environment

     

       22
       22
       -
       +      if let nixCC = env["NIX_CC"],

     

       23
       23
       -
       +         let binPath = try? AbsolutePath(validating: "\(nixCC)/bin"),

     

       23
       23
       +
       +      if let binPath = try? AbsolutePath(validating: "@clang@/bin"),

     

       24
       24
        
       +         let tool = lookupExecutablePath(filename: parsedOptions.hasArgument(.enableExperimentalCxxInterop)

     

       25
       25
        
       +                                                        ? "clang++" : "clang",

     

       26
       26
        
       +                                         searchPaths: [binPath]) {

     
···

       30
       30
        
              if let toolsDirPath = parsedOptions.getLastArgument(.toolsDirectory) {

     

       31
       31
        
                // FIXME: What if this isn't an absolute path?

     

       32
       32
        
                let toolsDir = try AbsolutePath(validating: toolsDirPath.asSingle)

     

       33
       33
       -
       @@ -136,6 +150,7 @@ extension GenericUnixToolchain {

     

       33
       33
       +
       @@ -136,6 +148,7 @@

     

       34
       34
        
                commandLine.appendFlag("-B")

     

       35
       35
        
                commandLine.appendPath(toolsDir)

     

       36
       36
        
              }

     

       37
       37
       -
       +      } // nixCC

     

       37
       37
       +
       +      } // Nix

     

       38
       38
        
        

     

       39
       39
        
              // Executables on Linux get -pie

     

       40
       40
        
              if targetTriple.os == .linux && linkerOutputType == .executable {

-28

pkgs/development/compilers/swift/swift-driver/patches/nix-resource-root.patch

···

       1
       1
       -
       Swift normally looks for the Clang resource dir in a subdir/symlink of its own

     

       2
       2
       -
       resource dir. We provide a symlink to the Swift build-time Clang as a default

     

       3
       3
       -
       there, but we also here patch a check to try locate it via NIX_CC.

     

       4
       4
       -
       

     

       5
       5
       -
       --- a/Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift

     

       6
       6
       -
       +++ b/Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift

     

       7
       7
       -
       @@ -10,6 +10,7 @@

     

       8
       8
       -
        //

     

       9
       9
       -
        //===----------------------------------------------------------------------===//

     

       10
       10
       -
        

     

       11
       11
       -
       +import Foundation

     

       12
       12
       -
        import SwiftOptions

     

       13
       13
       -
        

     

       14
       14
       -
        import protocol TSCBasic.FileSystem

     

       15
       15
       -
       @@ -26,6 +27,13 @@ extension Toolchain {

     

       16
       16
       -
            for targetInfo: FrontendTargetInfo,

     

       17
       17
       -
            parsedOptions: inout ParsedOptions

     

       18
       18
       -
          ) throws -> VirtualPath {

     

       19
       19
       -
       +    let env = ProcessInfo.processInfo.environment

     

       20
       20
       -
       +    if let nixCC = env["NIX_CC"] {

     

       21
       21
       -
       +      return try VirtualPath(path: nixCC)

     

       22
       22
       -
       +        .appending(components: "resource-root", "lib",

     

       23
       23
       -
       +                   targetInfo.target.triple.platformName(conflatingDarwin: true)!)

     

       24
       24
       -
       +    }

     

       25
       25
       -
       +

     

       26
       26
       -
            return VirtualPath.lookup(targetInfo.runtimeResourcePath.path)

     

       27
       27
       -
              .appending(components: "clang", "lib",

     

       28
       28
       -
                         targetInfo.target.triple.platformName(conflatingDarwin: true)!)

+15

pkgs/development/compilers/swift/wrapper/default.nix

···

       4
       4
        
         swift,

     

       5
       5
        
         useSwiftDriver ? true,

     

       6
       6
        
         swift-driver,

     

       7
       7
       +
         clang,

     

       7
       8
        
       }:

     

       8
       9
        
       

     

       9
       10
        
       stdenv.mkDerivation (

     
···

       28
       29
        
             swiftStaticLibSubdir

     

       29
       30
        
             ;

     

       30
       31
        
           swiftDriver = lib.optionalString useSwiftDriver "${swift-driver}/bin/swift-driver";

     

       32
       32
       +
           cc_wrapper = clang.override (prev: {

     

       33
       33
       +
             extraBuildCommands =

     

       34
       34
       +
               prev.extraBuildCommands

     

       35
       35
       +
               # We need to use the resource directory corresponding to Swift’s

     

       36
       36
       +
               # version of Clang instead of passing along the one from the

     

       37
       37
       +
               # `cc-wrapper` flags.

     

       38
       38
       +
               + ''

     

       39
       39
       +
                 rm -r $out/resource-root

     

       40
       40
       +
                 substituteInPlace $out/nix-support/cc-cflags \

     

       41
       41
       +
                   --replace-fail \

     

       42
       42
       +
                     "-resource-dir=$out/resource-root" \

     

       43
       43
       +
                     "-resource-dir=${lib.getLib swift}/lib/swift/clang"

     

       44
       44
       +
               '';

     

       45
       45
       +
           });

     

       31
       46
        
       

     

       32
       47
        
           env.darwinMinVersion = lib.optionalString stdenv.targetPlatform.isDarwin (

     

       33
       48
        
             stdenv.targetPlatform.darwinMinVersion

+1 -1

pkgs/development/compilers/swift/wrapper/wrapper.sh

···

       8
       8
        
           set -x

     

       9
       9
        
       fi

     

       10
       10
        
       

     

       11
       11
       -
       cc_wrapper="${NIX_CC:-@default_cc_wrapper@}"

     

       11
       11
       +
       cc_wrapper="@cc_wrapper@"

     

       12
       12
        
       

     

       13
       13
        
       source $cc_wrapper/nix-support/utils.bash

     

       14
       14