From c364b9352eaa3321f258062380d44f0ceab70e1e Mon Sep 17 00:00:00 2001 From: Tristan Ross Date: Sat, 23 Aug 2025 20:43:47 -0700 Subject: [PATCH 1/2] pkgs/development/compilers/llvm: add replacement entrypoint using makeScopeWithSplicing' --- .../compilers/llvm/common/default.nix | 609 ++++++++---------- pkgs/development/compilers/llvm/default.nix | 13 +- pkgs/stdenv/darwin/default.nix | 309 ++++----- 3 files changed, 408 insertions(+), 523 deletions(-) diff --git a/pkgs/development/compilers/llvm/common/default.nix b/pkgs/development/compilers/llvm/common/default.nix index 2fc33f5263854..7b50943a0371d 100644 --- a/pkgs/development/compilers/llvm/common/default.nix +++ b/pkgs/development/compilers/llvm/common/default.nix @@ -6,23 +6,20 @@ lib, stdenv, libxcrypt, - substitute, - replaceVars, fetchFromGitHub, - fetchpatch, - fetchpatch2, overrideCC, wrapCCWith, wrapBintoolsWith, buildPackages, - buildLlvmTools, # tools, but from the previous stage, for cross - targetLlvmLibraries, # libraries, but from the next stage, for cross - targetLlvm, + buildLlvmPackages, + targetLlvmPackages, + makeScopeWithSplicing', + otherSplices, # This is the default binutils, but with *this* version of LLD rather # than the default LLVM version's, if LLD is the choice. We use these for # the `useLLVM` bootstrapping below. - bootBintoolsNoLibc ? if stdenv.targetPlatform.linker == "lld" then null else pkgs.bintoolsNoLibc, - bootBintools ? if stdenv.targetPlatform.linker == "lld" then null else pkgs.bintools, + bootBintoolsNoLibc, + bootBintools, darwin, gitRelease ? null, officialRelease ? null, @@ -110,16 +107,27 @@ let "${patchDir}/${p}"; }; }; - - tools = lib.makeExtensible ( - tools: +in +makeScopeWithSplicing' { + inherit otherSplices; + f = + llvmPackages: let - callPackage = newScope (tools // args // metadata); + callPackage = llvmPackages.newScope ( + args + // metadata + // { + buildLlvmTools = buildLlvmPackages; + targetLlvm = targetLlvmPackages.llvm; + } + ); + clangVersion = if (lib.versionOlder metadata.release_version "16") then metadata.release_version else lib.versions.major metadata.release_version; + mkExtraBuildCommands0 = cc: '' @@ -139,37 +147,41 @@ let ln -s "${lib.getLib cc}/lib/clang/${clangVersion}/include" "$rsrc" '' ); + mkExtraBuildCommandsBasicRt = cc: mkExtraBuildCommands0 cc + '' - ln -s "${targetLlvmLibraries.compiler-rt-no-libc.out}/lib" "$rsrc/lib" + ln -s "${targetLlvmPackages.compiler-rt-no-libc.out}/lib" "$rsrc/lib" ''; + mkExtraBuildCommands = cc: mkExtraBuildCommands0 cc + '' - ln -s "${targetLlvmLibraries.compiler-rt.out}/lib" "$rsrc/lib" - ln -s "${targetLlvmLibraries.compiler-rt.out}/share" "$rsrc/share" + ln -s "${targetLlvmPackages.compiler-rt.out}/lib" "$rsrc/lib" + ln -s "${targetLlvmPackages.compiler-rt.out}/share" "$rsrc/share" ''; - bintoolsNoLibc' = if bootBintoolsNoLibc == null then tools.bintoolsNoLibc else bootBintoolsNoLibc; - bintools' = if bootBintools == null then tools.bintools else bootBintools; + bintoolsNoLibc' = + if bootBintoolsNoLibc == null then llvmPackages.bintoolsNoLibc else bootBintoolsNoLibc; + bintools' = if bootBintools == null then llvmPackages.bintools else bootBintools; in { - libllvm = callPackage ./llvm { - }; + inherit (metadata) release_version; + + libllvm = callPackage ./llvm { }; # `llvm` historically had the binaries. When choosing an output explicitly, # we need to reintroduce `outputSpecified` to get the expected behavior e.g. of lib.get* - llvm = tools.libllvm; + llvm = llvmPackages.libllvm; tblgen = callPackage ./tblgen.nix { patches = builtins.filter # Crude method to drop polly patches if present, they're not needed for tblgen. (p: (!lib.hasInfix "-polly" p)) - tools.libllvm.patches; + llvmPackages.libllvm.patches; clangPatches = [ # Would take tools.libclang.patches, but this introduces a cycle due # to replacements depending on the llvm outpath (e.g. the LLVMgold patch). @@ -183,20 +195,19 @@ let (metadata.getVersionFile "clang/aarch64-tblgen.patch"); }; - libclang = callPackage ./clang { - }; + libclang = callPackage ./clang { }; - clang-unwrapped = tools.libclang; + clang-unwrapped = llvmPackages.libclang; llvm-manpages = lowPrio ( - tools.libllvm.override { + llvmPackages.libllvm.override { enableManpages = true; python3 = pkgs.python3; # don't use python-boot } ); clang-manpages = lowPrio ( - tools.libclang.override { + llvmPackages.libclang.override { enableManpages = true; python3 = pkgs.python3; # don't use python-boot } @@ -208,44 +219,41 @@ let # pick clang appropriate for package set we are targeting clang = if stdenv.targetPlatform.libc == null then - tools.clangNoLibc + llvmPackages.clangNoLibc else if stdenv.targetPlatform.useLLVM or false then - tools.clangUseLLVM + llvmPackages.clangUseLLVM else if (pkgs.targetPackages.stdenv or args.stdenv).cc.isGNU then - tools.libstdcxxClang + llvmPackages.libstdcxxClang else - tools.libcxxClang; + llvmPackages.libcxxClang; libstdcxxClang = wrapCCWith rec { - cc = tools.clang-unwrapped; + cc = llvmPackages.clang-unwrapped; # libstdcxx is taken from gcc in an ad-hoc way in cc-wrapper. libcxx = null; - extraPackages = [ targetLlvmLibraries.compiler-rt ]; + extraPackages = [ targetLlvmPackages.compiler-rt ]; extraBuildCommands = mkExtraBuildCommands cc; }; libcxxClang = wrapCCWith rec { - cc = tools.clang-unwrapped; - libcxx = targetLlvmLibraries.libcxx; - extraPackages = [ targetLlvmLibraries.compiler-rt ]; + cc = llvmPackages.clang-unwrapped; + libcxx = targetLlvmPackages.libcxx; + extraPackages = [ targetLlvmPackages.compiler-rt ]; extraBuildCommands = mkExtraBuildCommands cc; }; - lld = callPackage ./lld { - }; + lld = callPackage ./lld { }; lldbPlugins = lib.makeExtensible ( lldbPlugins: let - callPackage = newScope (lldbPlugins // tools // args // metadata); + callPackage = newScope (lldbPlugins // llvmPackages // args // metadata); in lib.recurseIntoAttrs { llef = callPackage ./lldb-plugins/llef.nix { }; } ); lldb = callPackage ./lldb ( - { - } - // lib.optionalAttrs (lib.versions.major metadata.release_version == "16") { + lib.optionalAttrs (lib.versions.major metadata.release_version == "16") { src = callPackage ( { runCommand }: runCommand "lldb-src-${metadata.version}" { } '' @@ -267,209 +275,214 @@ let bintools-unwrapped = callPackage ./bintools.nix { }; bintoolsNoLibc = wrapBintoolsWith { - bintools = tools.bintools-unwrapped; + bintools = llvmPackages.bintools-unwrapped; libc = targetPackages.preLibcHeaders; }; - bintools = wrapBintoolsWith { bintools = tools.bintools-unwrapped; }; - - clangUseLLVM = wrapCCWith ( - rec { - cc = tools.clang-unwrapped; - libcxx = targetLlvmLibraries.libcxx; - bintools = bintools'; - extraPackages = [ - targetLlvmLibraries.compiler-rt - ] - ++ lib.optionals (!stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD) [ - targetLlvmLibraries.libunwind - ]; - extraBuildCommands = - lib.optionalString (lib.versions.major metadata.release_version == "13") ( - '' - echo "-rtlib=compiler-rt -Wno-unused-command-line-argument" >> $out/nix-support/cc-cflags - echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags - '' - + lib.optionalString (!stdenv.targetPlatform.isWasm) '' - echo "--unwindlib=libunwind" >> $out/nix-support/cc-cflags - echo "-L${targetLlvmLibraries.libunwind}/lib" >> $out/nix-support/cc-ldflags - '' - + lib.optionalString (!stdenv.targetPlatform.isWasm && stdenv.targetPlatform.useLLVM or false) '' - echo "-lunwind" >> $out/nix-support/cc-ldflags - '' - + lib.optionalString stdenv.targetPlatform.isWasm '' - echo "-fno-exceptions" >> $out/nix-support/cc-cflags - '' - ) - + mkExtraBuildCommands cc; - } - // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "14") { - nixSupport.cc-cflags = [ - "-rtlib=compiler-rt" - "-Wno-unused-command-line-argument" - "-B${targetLlvmLibraries.compiler-rt}/lib" - ] - ++ lib.optional ( - !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD - ) "--unwindlib=libunwind" - ++ lib.optional ( - !stdenv.targetPlatform.isWasm - && !stdenv.targetPlatform.isFreeBSD - && stdenv.targetPlatform.useLLVM or false - ) "-lunwind" - ++ lib.optional stdenv.targetPlatform.isWasm "-fno-exceptions"; - nixSupport.cc-ldflags = lib.optionals ( - !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD - ) [ "-L${targetLlvmLibraries.libunwind}/lib" ]; - } - ); + bintools = wrapBintoolsWith { + bintools = llvmPackages.bintools-unwrapped; + }; - clangWithLibcAndBasicRtAndLibcxx = wrapCCWith ( - rec { - cc = tools.clang-unwrapped; - libcxx = targetLlvmLibraries.libcxx; - bintools = bintools'; - extraPackages = [ - targetLlvmLibraries.compiler-rt-no-libc - ] - ++ - lib.optionals - ( - !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD && !stdenv.targetPlatform.isDarwin - ) - [ - targetLlvmLibraries.libunwind - ]; - extraBuildCommands = - lib.optionalString (lib.versions.major metadata.release_version == "13") ( - '' - echo "-rtlib=compiler-rt -Wno-unused-command-line-argument" >> $out/nix-support/cc-cflags - echo "-B${targetLlvmLibraries.compiler-rt-no-libc}/lib" >> $out/nix-support/cc-cflags - '' - + lib.optionalString (!stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isDarwin) '' - echo "--unwindlib=libunwind" >> $out/nix-support/cc-cflags - echo "-L${targetLlvmLibraries.libunwind}/lib" >> $out/nix-support/cc-ldflags - '' - + lib.optionalString (!stdenv.targetPlatform.isWasm && stdenv.targetPlatform.useLLVM or false) '' - echo "-lunwind" >> $out/nix-support/cc-ldflags - '' - + lib.optionalString stdenv.targetPlatform.isWasm '' - echo "-fno-exceptions" >> $out/nix-support/cc-cflags - '' + clangUseLLVM = wrapCCWith (rec { + cc = llvmPackages.clang-unwrapped; + libcxx = targetLlvmPackages.libcxx; + bintools = bintools'; + extraPackages = [ + targetLlvmPackages.compiler-rt + ] + ++ lib.optionals (!stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD) [ + targetLlvmPackages.libunwind + ]; + extraBuildCommands = mkExtraBuildCommands cc; + nixSupport.cc-cflags = [ + "-rtlib=compiler-rt" + "-Wno-unused-command-line-argument" + "-B${targetLlvmPackages.compiler-rt}/lib" + ] + ++ lib.optional ( + !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD + ) "--unwindlib=libunwind" + ++ lib.optional ( + !stdenv.targetPlatform.isWasm + && !stdenv.targetPlatform.isFreeBSD + && stdenv.targetPlatform.useLLVM or false + ) "-lunwind" + ++ lib.optional stdenv.targetPlatform.isWasm "-fno-exceptions"; + nixSupport.cc-ldflags = lib.optionals ( + !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD + ) [ "-L${targetLlvmPackages.libunwind}/lib" ]; + }); + + clangWithLibcAndBasicRtAndLibcxx = wrapCCWith (rec { + cc = llvmPackages.clang-unwrapped; + libcxx = targetLlvmPackages.libcxx; + bintools = bintools'; + extraPackages = [ + targetLlvmPackages.compiler-rt-no-libc + ] + ++ + lib.optionals + ( + !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD && !stdenv.targetPlatform.isDarwin ) - + mkExtraBuildCommandsBasicRt cc; - } - // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "14") { - nixSupport.cc-cflags = [ - "-rtlib=compiler-rt" - "-Wno-unused-command-line-argument" - "-B${targetLlvmLibraries.compiler-rt-no-libc}/lib" - ] - ++ lib.optional ( - !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD && !stdenv.targetPlatform.isDarwin - ) "--unwindlib=libunwind" - ++ lib.optional ( - !stdenv.targetPlatform.isWasm - && !stdenv.targetPlatform.isFreeBSD - && stdenv.targetPlatform.useLLVM or false - ) "-lunwind" - ++ lib.optional stdenv.targetPlatform.isWasm "-fno-exceptions"; - nixSupport.cc-ldflags = lib.optionals ( - !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD && !stdenv.targetPlatform.isDarwin - ) [ "-L${targetLlvmLibraries.libunwind}/lib" ]; - } - ); + [ + targetLlvmPackages.libunwind + ]; + extraBuildCommands = mkExtraBuildCommandsBasicRt cc; + nixSupport.cc-cflags = [ + "-rtlib=compiler-rt" + "-Wno-unused-command-line-argument" + "-B${targetLlvmPackages.compiler-rt-no-libc}/lib" + ] + ++ lib.optional ( + !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD && !stdenv.targetPlatform.isDarwin + ) "--unwindlib=libunwind" + ++ lib.optional ( + !stdenv.targetPlatform.isWasm + && !stdenv.targetPlatform.isFreeBSD + && stdenv.targetPlatform.useLLVM or false + ) "-lunwind" + ++ lib.optional stdenv.targetPlatform.isWasm "-fno-exceptions"; + nixSupport.cc-ldflags = lib.optionals ( + !stdenv.targetPlatform.isWasm && !stdenv.targetPlatform.isFreeBSD && !stdenv.targetPlatform.isDarwin + ) [ "-L${targetLlvmPackages.libunwind}/lib" ]; + }); + + clangWithLibcAndBasicRt = wrapCCWith (rec { + cc = llvmPackages.clang-unwrapped; + libcxx = null; + bintools = bintools'; + extraPackages = [ targetLlvmPackages.compiler-rt-no-libc ]; + extraBuildCommands = mkExtraBuildCommandsBasicRt cc; + nixSupport.cc-cflags = [ + "-rtlib=compiler-rt" + "-B${targetLlvmPackages.compiler-rt-no-libc}/lib" + "-nostdlib++" + ] + ++ lib.optional ( + lib.versionAtLeast metadata.release_version "15" && stdenv.targetPlatform.isWasm + ) "-fno-exceptions"; + }); - clangWithLibcAndBasicRt = wrapCCWith ( - rec { - cc = tools.clang-unwrapped; - libcxx = null; - bintools = bintools'; - extraPackages = [ targetLlvmLibraries.compiler-rt-no-libc ]; - extraBuildCommands = - lib.optionalString (lib.versions.major metadata.release_version == "13") '' - echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags - echo "-B${targetLlvmLibraries.compiler-rt-no-libc}/lib" >> $out/nix-support/cc-cflags - echo "-nostdlib++" >> $out/nix-support/cc-cflags - '' - + mkExtraBuildCommandsBasicRt cc; - } - // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "14") { - nixSupport.cc-cflags = [ - "-rtlib=compiler-rt" - "-B${targetLlvmLibraries.compiler-rt-no-libc}/lib" - "-nostdlib++" - ] - ++ lib.optional ( - lib.versionAtLeast metadata.release_version "15" && stdenv.targetPlatform.isWasm - ) "-fno-exceptions"; - } - ); + clangNoLibcWithBasicRt = wrapCCWith (rec { + cc = llvmPackages.clang-unwrapped; + libcxx = null; + bintools = bintoolsNoLibc'; + extraPackages = [ targetLlvmPackages.compiler-rt-no-libc ]; + extraBuildCommands = mkExtraBuildCommandsBasicRt cc; + nixSupport.cc-cflags = [ + "-rtlib=compiler-rt" + "-B${targetLlvmPackages.compiler-rt-no-libc}/lib" + ] + ++ lib.optional ( + lib.versionAtLeast metadata.release_version "15" && stdenv.targetPlatform.isWasm + ) "-fno-exceptions"; + }); - clangNoLibcWithBasicRt = wrapCCWith ( - rec { - cc = tools.clang-unwrapped; - libcxx = null; - bintools = bintoolsNoLibc'; - extraPackages = [ targetLlvmLibraries.compiler-rt-no-libc ]; - extraBuildCommands = - lib.optionalString (lib.versions.major metadata.release_version == "13") '' - echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags - echo "-B${targetLlvmLibraries.compiler-rt-no-libc}/lib" >> $out/nix-support/cc-cflags - '' - + mkExtraBuildCommandsBasicRt cc; + clangNoLibcNoRt = wrapCCWith (rec { + cc = llvmPackages.clang-unwrapped; + libcxx = null; + bintools = bintoolsNoLibc'; + extraPackages = [ ]; + extraBuildCommands = mkExtraBuildCommands0 cc; + # "-nostartfiles" used to be needed for pkgsLLVM, causes problems so don't include it. + nixSupport.cc-cflags = lib.optional ( + lib.versionAtLeast metadata.release_version "15" && stdenv.targetPlatform.isWasm + ) "-fno-exceptions"; + }); + + # This is an "oddly ordered" bootstrap just for Darwin. Probably + # don't want it otherwise. + clangNoCompilerRtWithLibc = wrapCCWith rec { + cc = llvmPackages.clang-unwrapped; + libcxx = null; + bintools = bintools'; + extraPackages = [ ]; + extraBuildCommands = mkExtraBuildCommands0 cc; + nixSupport.cc-cflags = [ "-fno-exceptions" ]; + }; + + # Aliases + clangNoCompilerRt = llvmPackages.clangNoLibcNoRt; + clangNoLibc = llvmPackages.clangNoLibcWithBasicRt; + clangNoLibcxx = llvmPackages.clangWithLibcAndBasicRt; + + compiler-rt-libc = callPackage ./compiler-rt ( + let + # temp rename to avoid infinite recursion + stdenv = + # Darwin needs to use a bootstrap stdenv to avoid an infinite recursion when cross-compiling. + if args.stdenv.hostPlatform.isDarwin then + overrideCC darwin.bootstrapStdenv buildLlvmPackages.clangWithLibcAndBasicRtAndLibcxx + else if args.stdenv.hostPlatform.useLLVM or false then + overrideCC args.stdenv buildLlvmPackages.clangWithLibcAndBasicRtAndLibcxx + else + args.stdenv; + in + { + inherit stdenv; } - // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "14") { - nixSupport.cc-cflags = [ - "-rtlib=compiler-rt" - "-B${targetLlvmLibraries.compiler-rt-no-libc}/lib" - ] - ++ lib.optional ( - lib.versionAtLeast metadata.release_version "15" && stdenv.targetPlatform.isWasm - ) "-fno-exceptions"; + // lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) { + libxcrypt = (libxcrypt.override { inherit stdenv; }).overrideAttrs (old: { + configureFlags = old.configureFlags ++ [ "--disable-symvers" ]; + }); } ); - clangNoLibcNoRt = wrapCCWith ( - rec { - cc = tools.clang-unwrapped; - libcxx = null; - bintools = bintoolsNoLibc'; - extraPackages = [ ]; - # "-nostartfiles" used to be needed for pkgsLLVM, causes problems so don't include it. - extraBuildCommands = mkExtraBuildCommands0 cc; + compiler-rt-no-libc = callPackage ./compiler-rt { + doFakeLibgcc = stdenv.hostPlatform.useLLVM or false; + stdenv = + # Darwin needs to use a bootstrap stdenv to avoid an infinite recursion when cross-compiling. + if stdenv.hostPlatform.isDarwin then + overrideCC darwin.bootstrapStdenv buildLlvmPackages.clangNoLibcNoRt + else + overrideCC stdenv buildLlvmPackages.clangNoLibcNoRt; + }; + + compiler-rt = + if + stdenv.hostPlatform.libc == null + # Building the with-libc compiler-rt and WASM doesn't yet work, + # because wasilibc doesn't provide some expected things. See + # compiler-rt's file for further details. + || stdenv.hostPlatform.isWasm + # Failing `#include ` in + # `lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp` + # sanitizers, not sure where to get it. + || stdenv.hostPlatform.isFreeBSD + then + llvmPackages.compiler-rt-no-libc + else + llvmPackages.compiler-rt-libc; + + stdenv = overrideCC stdenv buildLlvmPackages.clang; + + libcxxStdenv = overrideCC stdenv buildLlvmPackages.libcxxClang; + + libcxx = callPackage ./libcxx ( + { + stdenv = + if stdenv.hostPlatform.isDarwin then + overrideCC darwin.bootstrapStdenv buildLlvmPackages.clangWithLibcAndBasicRt + else + overrideCC stdenv buildLlvmPackages.clangWithLibcAndBasicRt; } - // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "14") { - # "-nostartfiles" used to be needed for pkgsLLVM, causes problems so don't include it. - nixSupport.cc-cflags = lib.optional ( - lib.versionAtLeast metadata.release_version "15" && stdenv.targetPlatform.isWasm - ) "-fno-exceptions"; + // lib.optionalAttrs (lib.versionOlder metadata.release_version "14") { + # TODO: remove this, causes LLVM 13 packages rebuild. + inherit (metadata) monorepoSrc; # Preserve bug during #307211 refactor. } ); - # This is an "oddly ordered" bootstrap just for Darwin. Probably - # don't want it otherwise. - clangNoCompilerRtWithLibc = - wrapCCWith rec { - cc = tools.clang-unwrapped; - libcxx = null; - bintools = bintools'; - extraPackages = [ ]; - extraBuildCommands = mkExtraBuildCommands0 cc; - } - // lib.optionalAttrs ( - lib.versionAtLeast metadata.release_version "15" && stdenv.targetPlatform.isWasm - ) { nixSupport.cc-cflags = [ "-fno-exceptions" ]; }; + libunwind = callPackage ./libunwind { + stdenv = overrideCC stdenv buildLlvmPackages.clangWithLibcAndBasicRt; + }; - # Aliases - clangNoCompilerRt = tools.clangNoLibcNoRt; - clangNoLibc = tools.clangNoLibcWithBasicRt; - clangNoLibcxx = tools.clangWithLibcAndBasicRt; + openmp = callPackage ./openmp { }; } // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "15") { # TODO: pre-15: lldb/docs/index.rst:155:toctree contains reference to nonexisting document 'design/structureddataplugins' lldb-manpages = lowPrio ( - tools.lldb.override { + llvmPackages.lldb.override { enableManpages = true; python3 = pkgs.python3; # don't use python-boot } @@ -479,8 +492,7 @@ let mlir = callPackage ./mlir { }; } // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "19") { - bolt = callPackage ./bolt { - }; + bolt = callPackage ./bolt { }; } // lib.optionalAttrs @@ -490,130 +502,31 @@ let } // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "20") { flang = callPackage ./flang { - mlir = tools.mlir; + inherit (targetLlvmPackages) mlir; }; - } - ); - libraries = lib.makeExtensible ( - libraries: - let - callPackage = newScope ( - libraries - // buildLlvmTools - // args - // metadata - # Previously monorepoSrc was erroneously not being passed through. - // lib.optionalAttrs (lib.versionOlder metadata.release_version "14") { monorepoSrc = null; } # Preserve a bug during #307211, TODO: remove; causes llvm 13 rebuild. - ); - in - ( - { - compiler-rt-libc = callPackage ./compiler-rt ( - let - # temp rename to avoid infinite recursion - stdenv = - # Darwin needs to use a bootstrap stdenv to avoid an infinite recursion when cross-compiling. - if args.stdenv.hostPlatform.isDarwin then - overrideCC darwin.bootstrapStdenv buildLlvmTools.clangWithLibcAndBasicRtAndLibcxx - else if args.stdenv.hostPlatform.useLLVM or false then - overrideCC args.stdenv buildLlvmTools.clangWithLibcAndBasicRtAndLibcxx - else - args.stdenv; - in - { - inherit stdenv; - } - // lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) { - libxcrypt = (libxcrypt.override { inherit stdenv; }).overrideAttrs (old: { - configureFlags = old.configureFlags ++ [ "--disable-symvers" ]; - }); - } - ); + libc-overlay = callPackage ./libc { + isFullBuild = false; + # Use clang due to "gnu::naked" not working on aarch64. + # Issue: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77882 + stdenv = overrideCC stdenv buildLlvmPackages.clang; + }; - compiler-rt-no-libc = callPackage ./compiler-rt { - doFakeLibgcc = stdenv.hostPlatform.useLLVM or false; - stdenv = - # Darwin needs to use a bootstrap stdenv to avoid an infinite recursion when cross-compiling. - if stdenv.hostPlatform.isDarwin then - overrideCC darwin.bootstrapStdenv buildLlvmTools.clangNoLibcNoRt - else - overrideCC stdenv buildLlvmTools.clangNoLibcNoRt; - }; - - compiler-rt = - if - stdenv.hostPlatform.libc == null - # Building the with-libc compiler-rt and WASM doesn't yet work, - # because wasilibc doesn't provide some expected things. See - # compiler-rt's file for further details. - || stdenv.hostPlatform.isWasm - # Failing `#include ` in - # `lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp` - # sanitizers, not sure where to get it. - || stdenv.hostPlatform.isFreeBSD - then - libraries.compiler-rt-no-libc + libc-full = callPackage ./libc { + isFullBuild = true; + # Use clang due to "gnu::naked" not working on aarch64. + # Issue: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77882 + stdenv = overrideCC stdenv buildLlvmPackages.clangNoLibcNoRt; + cmake = + if stdenv.targetPlatform.libc == "llvm" then buildPackages.cmakeMinimal else buildPackages.cmake; + python3 = + if stdenv.targetPlatform.libc == "llvm" then + buildPackages.python3Minimal else - libraries.compiler-rt-libc; - - stdenv = overrideCC stdenv buildLlvmTools.clang; - - libcxxStdenv = overrideCC stdenv buildLlvmTools.libcxxClang; - - libcxx = callPackage ./libcxx ( - { - stdenv = - if stdenv.hostPlatform.isDarwin then - overrideCC darwin.bootstrapStdenv buildLlvmTools.clangWithLibcAndBasicRt - else - overrideCC stdenv buildLlvmTools.clangWithLibcAndBasicRt; - } - // lib.optionalAttrs (lib.versionOlder metadata.release_version "14") { - # TODO: remove this, causes LLVM 13 packages rebuild. - inherit (metadata) monorepoSrc; # Preserve bug during #307211 refactor. - } - ); - - libunwind = callPackage ./libunwind { - stdenv = overrideCC stdenv buildLlvmTools.clangWithLibcAndBasicRt; - }; - - openmp = callPackage ./openmp { - }; - } - // lib.optionalAttrs (lib.versionAtLeast metadata.release_version "20") { - libc-overlay = callPackage ./libc { - isFullBuild = false; - # Use clang due to "gnu::naked" not working on aarch64. - # Issue: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77882 - stdenv = overrideCC stdenv buildLlvmTools.clang; - }; - - libc-full = callPackage ./libc { - isFullBuild = true; - # Use clang due to "gnu::naked" not working on aarch64. - # Issue: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77882 - stdenv = overrideCC stdenv buildLlvmTools.clangNoLibcNoRt; - cmake = - if stdenv.targetPlatform.libc == "llvm" then buildPackages.cmakeMinimal else buildPackages.cmake; - python3 = - if stdenv.targetPlatform.libc == "llvm" then - buildPackages.python3Minimal - else - buildPackages.python3; - }; - - libc = if stdenv.targetPlatform.libc == "llvm" then libraries.libc-full else libraries.libc-overlay; - } - ) - ); + buildPackages.python3; + }; - noExtend = extensible: lib.attrsets.removeAttrs extensible [ "extend" ]; -in -{ - inherit tools libraries; - inherit (metadata) release_version; + libc = + if stdenv.targetPlatform.libc == "llvm" then llvmPackages.libc-full else llvmPackages.libc-overlay; + }; } -// (noExtend libraries) -// (noExtend tools) diff --git a/pkgs/development/compilers/llvm/default.nix b/pkgs/development/compilers/llvm/default.nix index de99df185d520..e3c1a9322e5ff 100644 --- a/pkgs/development/compilers/llvm/default.nix +++ b/pkgs/development/compilers/llvm/default.nix @@ -13,6 +13,7 @@ bootBintoolsNoLibc ? if stdenv.targetPlatform.linker == "lld" then null else pkgs.bintoolsNoLibc, bootBintools ? if stdenv.targetPlatform.linker == "lld" then null else pkgs.bintools, llvmVersions ? { }, + generateSplicesForMkScope, patchesFn ? lib.id, # Allows passthrough to packages via newScope in ./common/default.nix. # This makes it possible to do @@ -65,19 +66,19 @@ let callPackage ./common ( { inherit (stdenvAdapters) overrideCC; - buildLlvmTools = buildPackages."llvmPackages_${attrName}".tools; - targetLlvmLibraries = - # Allow overriding targetLlvmLibraries; this enables custom runtime builds. - packageSetArgs.targetLlvmLibraries or targetPackages."llvmPackages_${attrName}".libraries - or llvmPackages."${attrName}".libraries; - targetLlvm = targetPackages."llvmPackages_${attrName}".llvm or llvmPackages."${attrName}".llvm; inherit officialRelease gitRelease monorepoSrc version patchesFn + bootBintools + bootBintoolsNoLibc ; + + buildLlvmPackages = buildPackages."llvmPackages_${attrName}"; + targetLlvmPackages = targetPackages."llvmPackages_${attrName}" or llvmPackages."${attrName}"; + otherSplices = generateSplicesForMkScope "llvmPackages_${attrName}"; } // packageSetArgs # Allow overrides. ) diff --git a/pkgs/stdenv/darwin/default.nix b/pkgs/stdenv/darwin/default.nix index d7f4145ed3b95..977ee9b58b8b9 100644 --- a/pkgs/stdenv/darwin/default.nix +++ b/pkgs/stdenv/darwin/default.nix @@ -457,98 +457,87 @@ assert bootstrapTools.passthru.isFromBootstrapFiles or false; # sanity check } ); - llvmPackages = - super.llvmPackages - // ( - let - tools = super.llvmPackages.tools.extend ( - selfTools: _: { - libclang = self.stdenv.mkDerivation { - name = "bootstrap-stage0-clang"; - version = "boot"; - outputs = [ - "out" - "lib" - ]; - buildCommand = '' - mkdir -p $out/lib - ln -s $out $lib - ln -s ${bootstrapTools}/bin $out/bin - ln -s ${bootstrapTools}/lib/clang $out/lib - ln -s ${bootstrapTools}/include $out - ''; - passthru = { - isFromBootstrapFiles = true; - hardeningUnsupportedFlags = [ - "fortify3" - "pacret" - "shadowstack" - "stackclashprotection" - "zerocallusedregs" - ]; - }; - }; - libllvm = self.stdenv.mkDerivation { - name = "bootstrap-stage0-llvm"; - outputs = [ - "out" - "lib" - ]; - buildCommand = '' - mkdir -p $out/bin $out/lib - ln -s $out $lib - for tool in ${toString super.darwin.binutils-unwrapped.llvm_cmds}; do - cctoolsTool=''${tool//-/_} - toolsrc="${bootstrapTools}/bin/$cctoolsTool" - if [ -e "$toolsrc" ]; then - ln -s "$toolsrc" $out/bin/llvm-$tool - fi - done - ln -s ${bootstrapTools}/bin/dsymutil $out/bin/dsymutil - ln -s ${bootstrapTools}/bin/llvm-readtapi $out/bin/llvm-readtapi - ln -s ${bootstrapTools}/lib/libLLVM* $out/lib - ''; - passthru.isFromBootstrapFiles = true; - }; - llvm-manpages = self.llvmPackages.libllvm; - lld = self.stdenv.mkDerivation { - name = "bootstrap-stage0-lld"; - buildCommand = ""; - passthru = { - isLLVM = true; - isFromBootstrapFiles = true; - }; - }; - } - ); - libraries = super.llvmPackages.libraries.extend ( - _: _: { - compiler-rt = self.stdenv.mkDerivation { - name = "bootstrap-stage0-compiler-rt"; - buildCommand = '' - mkdir -p $out/lib $out/share - ln -s ${bootstrapTools}/lib/libclang_rt* $out/lib - ln -s ${bootstrapTools}/lib/darwin $out/lib - ''; - passthru.isFromBootstrapFiles = true; - }; - libcxx = self.stdenv.mkDerivation { - name = "bootstrap-stage0-libcxx"; - buildCommand = '' - mkdir -p $out/lib $out/include - ln -s ${bootstrapTools}/lib/libc++.dylib $out/lib - ln -s ${bootstrapTools}/include/c++ $out/include - ''; - passthru = { - isLLVM = true; - isFromBootstrapFiles = true; - }; - }; - } - ); - in - { inherit tools libraries; } // tools // libraries - ); + llvmPackages = super.llvmPackages.overrideScope ( + selfLlvmPackages: _: { + libclang = self.stdenv.mkDerivation { + name = "bootstrap-stage0-clang"; + version = "boot"; + outputs = [ + "out" + "lib" + ]; + buildCommand = '' + mkdir -p $out/lib + ln -s $out $lib + ln -s ${bootstrapTools}/bin $out/bin + ln -s ${bootstrapTools}/lib/clang $out/lib + ln -s ${bootstrapTools}/include $out + ''; + passthru = { + isFromBootstrapFiles = true; + hardeningUnsupportedFlags = [ + "fortify3" + "pacret" + "shadowstack" + "stackclashprotection" + "zerocallusedregs" + ]; + }; + }; + libllvm = self.stdenv.mkDerivation { + name = "bootstrap-stage0-llvm"; + outputs = [ + "out" + "lib" + ]; + buildCommand = '' + mkdir -p $out/bin $out/lib + ln -s $out $lib + for tool in ${toString super.darwin.binutils-unwrapped.llvm_cmds}; do + cctoolsTool=''${tool//-/_} + toolsrc="${bootstrapTools}/bin/$cctoolsTool" + if [ -e "$toolsrc" ]; then + ln -s "$toolsrc" $out/bin/llvm-$tool + fi + done + ln -s ${bootstrapTools}/bin/dsymutil $out/bin/dsymutil + ln -s ${bootstrapTools}/bin/llvm-readtapi $out/bin/llvm-readtapi + ln -s ${bootstrapTools}/lib/libLLVM* $out/lib + ''; + passthru.isFromBootstrapFiles = true; + }; + llvm-manpages = self.llvmPackages.libllvm; + lld = self.stdenv.mkDerivation { + name = "bootstrap-stage0-lld"; + buildCommand = ""; + passthru = { + isLLVM = true; + isFromBootstrapFiles = true; + }; + }; + compiler-rt = self.stdenv.mkDerivation { + name = "bootstrap-stage0-compiler-rt"; + buildCommand = '' + mkdir -p $out/lib $out/share + ln -s ${bootstrapTools}/lib/libclang_rt* $out/lib + ln -s ${bootstrapTools}/lib/darwin $out/lib + ''; + passthru.isFromBootstrapFiles = true; + }; + libcxx = self.stdenv.mkDerivation { + name = "bootstrap-stage0-libcxx"; + buildCommand = '' + mkdir -p $out/lib $out/include + ln -s ${bootstrapTools}/lib/libc++.dylib $out/lib + ln -s ${bootstrapTools}/include/c++ $out/include + ''; + passthru = { + isLLVM = true; + isFromBootstrapFiles = true; + }; + }; + } + ); }; extraPreHook = '' @@ -673,12 +662,9 @@ assert bootstrapTools.passthru.isFromBootstrapFiles or false; # sanity check } ); - llvmPackages = - let - tools = super.llvmPackages.tools.extend (_: _: llvmToolsPackages prevStage); - libraries = super.llvmPackages.libraries.extend (_: _: llvmLibrariesPackages prevStage); - in - super.llvmPackages // { inherit tools libraries; } // tools // libraries; + llvmPackages = super.llvmPackages.overrideScope ( + _: _: llvmToolsPackages prevStage // llvmLibrariesPackages prevStage + ); }; extraNativeBuildInputs = lib.optionals localSystem.isAarch64 [ @@ -824,14 +810,14 @@ assert bootstrapTools.passthru.isFromBootstrapFiles or false; # sanity check } ); - llvmPackages = - let - tools = super.llvmPackages.tools.extend ( - _: _: llvmToolsPackages prevStage // { inherit (prevStage.llvmPackages) clangNoCompilerRtWithLibc; } - ); - libraries = super.llvmPackages.libraries.extend (_: _: llvmLibrariesPackages prevStage); - in - super.llvmPackages // { inherit tools libraries; } // tools // libraries; + llvmPackages = super.llvmPackages.overrideScope ( + _: _: + llvmToolsPackages prevStage + // llvmLibrariesPackages prevStage + // { + inherit (prevStage.llvmPackages) clangNoCompilerRtWithLibc; + } + ); } ]; @@ -906,11 +892,7 @@ assert bootstrapTools.passthru.isFromBootstrapFiles or false; # sanity check } ); - llvmPackages = - let - libraries = super.llvmPackages.libraries.extend (_: _: llvmLibrariesPackages prevStage); - in - super.llvmPackages // { inherit libraries; } // libraries; + llvmPackages = super.llvmPackages.overrideScope (_: _: llvmLibrariesPackages prevStage); } ]; @@ -980,49 +962,45 @@ assert bootstrapTools.passthru.isFromBootstrapFiles or false; # sanity check } ); - llvmPackages = - let - tools = super.llvmPackages.tools.extend ( - _: _: - llvmToolsPackages prevStage - // { - libcxxClang = super.wrapCCWith rec { - nativeTools = false; - nativeLibc = false; - - inherit (prevStage) expand-response-params; - - extraPackages = [ self.llvmPackages.compiler-rt ]; - - extraBuildCommands = '' - rsrc="$out/resource-root" - mkdir "$rsrc" - ln -s "${lib.getLib cc}/lib/clang/${lib.versions.major (lib.getVersion cc)}/include" "$rsrc" - echo "-resource-dir=$rsrc" >> $out/nix-support/cc-cflags - ln -s "${prevStage.llvmPackages.compiler-rt.out}/lib" "$rsrc/lib" - ln -s "${prevStage.llvmPackages.compiler-rt.out}/share" "$rsrc/share" - ''; - - cc = self.llvmPackages.clang-unwrapped; - bintools = self.darwin.binutils; - - isClang = true; - libc = self.darwin.libSystem; - inherit (self.llvmPackages) libcxx; - - inherit lib; - inherit (self) - stdenvNoCC - coreutils - gnugrep - runtimeShell - ; - }; - } - ); - libraries = super.llvmPackages.libraries.extend (_: _: llvmLibrariesPackages prevStage); - in - super.llvmPackages // { inherit tools libraries; } // tools // libraries; + llvmPackages = super.llvmPackages.overrideScope ( + _: _: + llvmToolsPackages prevStage + // llvmLibrariesPackages prevStage + // { + libcxxClang = super.wrapCCWith rec { + nativeTools = false; + nativeLibc = false; + + inherit (prevStage) expand-response-params; + + extraPackages = [ self.llvmPackages.compiler-rt ]; + + extraBuildCommands = '' + rsrc="$out/resource-root" + mkdir "$rsrc" + ln -s "${lib.getLib cc}/lib/clang/${lib.versions.major (lib.getVersion cc)}/include" "$rsrc" + echo "-resource-dir=$rsrc" >> $out/nix-support/cc-cflags + ln -s "${prevStage.llvmPackages.compiler-rt.out}/lib" "$rsrc/lib" + ln -s "${prevStage.llvmPackages.compiler-rt.out}/share" "$rsrc/share" + ''; + + cc = self.llvmPackages.clang-unwrapped; + bintools = self.darwin.binutils; + + isClang = true; + libc = self.darwin.libSystem; + inherit (self.llvmPackages) libcxx; + + inherit lib; + inherit (self) + stdenvNoCC + coreutils + gnugrep + runtimeShell + ; + }; + } + ); } ]; @@ -1232,22 +1210,15 @@ assert bootstrapTools.passthru.isFromBootstrapFiles or false; # sanity check "llvmPackages_${lib.versions.major prevStage.llvmPackages.release_version}" = let llvmVersion = lib.versions.major prevStage.llvmPackages.release_version; - tools = super."llvmPackages_${llvmVersion}".tools.extend (_: _: llvmToolsPackages prevStage); - libraries = super."llvmPackages_${llvmVersion}".libraries.extend ( - _: _: - llvmLibrariesPackages prevStage - # Avoid depending on llvm-manpages from the bootstrap, which brings a bunch of Python dependencies - # into the bootstrap. This means that there are no man pages in darwin.binutils, but they are still - # available from llvm-manpages, ld64, and cctools. - // { - inherit (super."llvmPackages_${llvmVersion}") llvm-manpages; - } - // lib.optionalAttrs (super.stdenv.targetPlatform == localSystem) { - inherit (prevStage.llvmPackages) clang; - } - ); in - super."llvmPackages_${llvmVersion}" // { inherit tools libraries; } // tools // libraries; + super."llvmPackages_${llvmVersion}".overrideScope ( + _: _: + llvmToolsPackages prevStage + // llvmLibrariesPackages prevStage + // { + inherit (super."llvmPackages_${llvmVersion}") llvm-manpages; + } + ); } ]; }; From acd183d2efb23f3877c448feec7d76bf6125b5dd Mon Sep 17 00:00:00 2001 From: Tristan Ross Date: Sun, 31 Aug 2025 21:17:28 -0700 Subject: [PATCH 2/2] llvmPackages_13.compiler-rt: fix missing libcxx source --- .../development/compilers/llvm/common/compiler-rt/default.nix | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pkgs/development/compilers/llvm/common/compiler-rt/default.nix b/pkgs/development/compilers/llvm/common/compiler-rt/default.nix index 40ff633527ae0..d60b14aefee6e 100644 --- a/pkgs/development/compilers/llvm/common/compiler-rt/default.nix +++ b/pkgs/development/compilers/llvm/common/compiler-rt/default.nix @@ -62,6 +62,10 @@ stdenv.mkDerivation (finalAttrs: { + lib.optionalString (lib.versionAtLeast release_version "14") '' cp -r ${monorepoSrc}/cmake "$out" '' + # Needs "libcxx/utils/merge_archives.py" + + lib.optionalString (lib.versions.major release_version == "13") '' + cp -r ${monorepoSrc}/libcxx "$out" + '' + lib.optionalString (lib.versionAtLeast release_version "21") '' cp -r ${monorepoSrc}/third-party "$out" ''