nordic-dev.net/nixpkgs
nordic-dev.net/nixpkgs
2
0
Fork 0
mirror of https://github.com/NixOS/nixpkgs.git synced 2024-11-22 15:03:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

[Backport staging-24.11] llvmPackages_12: build from monorepo source (#356654)

Browse Source
This commit is contained in:
Emily 2024-11-17 21:59:52 +00:00 committed by GitHub
commit bcf31aa3bd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 62 additions and 527 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
pkgs/development/compilers/llvm/common/compiler-rt/7-12-codesign.patch → pkgs/development/compilers/llvm/12/compiler-rt/codesign.patch
View File

445
pkgs/development/compilers/llvm/12/default.nix
View File

@ -1,445 +0,0 @@
{ lowPrio, newScope, pkgs, lib, stdenv
, preLibcCrossHeaders
, substitute, substituteAll, fetchFromGitHub, fetchpatch, fetchurl
, overrideCC, wrapCCWith, wrapBintoolsWith
, libxcrypt
, buildLlvmTools # tools, but from the previous stage, for cross
, targetLlvmLibraries # libraries, but from the next stage, for cross
, targetLlvm
# 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
, darwin
# Allows passthrough to packages via newScope. This makes it possible to
# do `(llvmPackages.override { <someLlvmDependency> = bar; }).clang` and get
# an llvmPackages whose packages are overridden in an internally consistent way.
, ...
}@args:
let
candidate = ""; # empty or "rcN"
dash-candidate = lib.optionalString (candidate != "") "-${candidate}";
metadata = rec {
release_version = "12.0.1";
version = "${release_version}${dash-candidate}"; # differentiating these (variables) is important for RCs
inherit (import ../common/common-let.nix { inherit lib release_version; }) llvm_meta;
fetch = name: sha256: fetchurl {
url = "https://github.com/llvm/llvm-project/releases/download/llvmorg-${metadata.version}/${name}-${metadata.release_version}${candidate}.src.tar.xz";
inherit sha256;
};
clang-tools-extra_src = fetch "clang-tools-extra" "1r9a4fdz9ci58b5z2inwvm4z4cdp6scrivnaw05dggkxz7yrwrb5";
};
inherit (metadata) fetch;
tools = lib.makeExtensible (tools: let
callPackage = newScope (tools // args // metadata);
mkExtraBuildCommands0 = cc: ''
rsrc="$out/resource-root"
mkdir "$rsrc"
ln -s "${cc.lib}/lib/clang/${metadata.release_version}/include" "$rsrc"
echo "-resource-dir=$rsrc" >> $out/nix-support/cc-cflags
'';
mkExtraBuildCommandsBasicRt = cc: mkExtraBuildCommands0 cc + ''
ln -s "${targetLlvmLibraries.compiler-rt-no-libc.out}/lib" "$rsrc/lib"
ln -s "${targetLlvmLibraries.compiler-rt-no-libc.out}/share" "$rsrc/share"
'';
mkExtraBuildCommands = cc: mkExtraBuildCommands0 cc + ''
ln -s "${targetLlvmLibraries.compiler-rt.out}/lib" "$rsrc/lib"
ln -s "${targetLlvmLibraries.compiler-rt.out}/share" "$rsrc/share"
'';
bintoolsNoLibc' =
if bootBintoolsNoLibc == null
then tools.bintoolsNoLibc
else bootBintoolsNoLibc;
bintools' =
if bootBintools == null
then tools.bintools
else bootBintools;
in {
libllvm = callPackage ../common/llvm {
src = fetch "llvm" "1pzx9zrmd7r3481sbhwvkms68fwhffpp4mmz45dgrkjpyl2q96kx";
polly_src = fetch "polly" "1yfm9ixda4a2sx7ak5vswijx4ydk5lv1c1xh39xmd2kh299y4m12";
patches = [
# When cross-compiling we configure llvm-config-native with an approximation
# of the flags used for the normal LLVM build. To avoid the need for building
# a native libLLVM.so (which would fail) we force llvm-config to be linked
# statically against the necessary LLVM components always.
../common/llvm/llvm-config-link-static.patch
# Fix llvm being miscompiled by some gccs. See llvm/llvm-project#49955
# Fix llvm being miscompiled by some gccs. See https://github.com/llvm/llvm-project/issues/49955
./llvm/fix-llvm-issue-49955.patch
./llvm/gnu-install-dirs.patch
# On older CPUs (e.g. Hydra/wendy) we'd be getting an error in this test.
(fetchpatch {
name = "uops-CMOV16rm-noreg.diff";
url = "https://github.com/llvm/llvm-project/commit/9e9f991ac033.diff";
sha256 = "sha256:12s8vr6ibri8b48h2z38f3afhwam10arfiqfy4yg37bmc054p5hi";
stripLen = 1;
})
# Fix musl build.
(fetchpatch {
url = "https://github.com/llvm/llvm-project/commit/5cd554303ead0f8891eee3cd6d25cb07f5a7bf67.patch";
relative = "llvm";
hash = "sha256-XPbvNJ45SzjMGlNUgt/IgEvM2dHQpDOe6woUJY+nUYA=";
})
# Backport gcc-13 fixes with missing includes.
(fetchpatch {
name = "signals-gcc-13.patch";
url = "https://github.com/llvm/llvm-project/commit/ff1681ddb303223973653f7f5f3f3435b48a1983.patch";
hash = "sha256-CXwYxQezTq5vdmc8Yn88BUAEly6YZ5VEIA6X3y5NNOs=";
stripLen = 1;
})
(fetchpatch {
name = "base64-gcc-13.patch";
url = "https://github.com/llvm/llvm-project/commit/5e9be93566f39ee6cecd579401e453eccfbe81e5.patch";
hash = "sha256-PAwrVrvffPd7tphpwCkYiz+67szPRzRB2TXBvKfzQ7U=";
stripLen = 1;
})
];
pollyPatches = [
./llvm/gnu-install-dirs-polly.patch
];
};
# `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;
libclang = callPackage ../common/clang {
src = fetch "clang" "0px4gl27az6cdz6adds89qzdwb1cqpjsfvrldbz9qvpmphrj34bf";
patches = [
./clang/purity.patch
# https://reviews.llvm.org/D51899
./clang/gnu-install-dirs.patch
(substituteAll {
src = ../common/clang/clang-11-15-LLVMgold-path.patch;
libllvmLibdir = "${tools.libllvm.lib}/lib";
})
];
};
clang-unwrapped = tools.libclang;
# disabled until recommonmark supports sphinx 3
#Llvm-manpages = lowPrio (tools.libllvm.override {
# enableManpages = true;
# python3 = pkgs.python3; # don't use python-boot
#});
clang-manpages = lowPrio (tools.libclang.override {
enableManpages = true;
python3 = pkgs.python3; # don't use python-boot
});
# disabled until recommonmark supports sphinx 3
# lldb-manpages = lowPrio (tools.lldb.override {
# enableManpages = true;
# python3 = pkgs.python3; # don't use python-boot
# });
# Wrapper for standalone command line utilities
clang-tools = callPackage ../common/clang-tools { };
# pick clang appropriate for package set we are targeting
clang =
/**/ if stdenv.targetPlatform.libc == null then tools.clangNoLibc
else if stdenv.targetPlatform.useLLVM or false then tools.clangUseLLVM
else if (pkgs.targetPackages.stdenv or stdenv).cc.isGNU then tools.libstdcxxClang
else tools.libcxxClang;
libstdcxxClang = wrapCCWith rec {
cc = tools.clang-unwrapped;
# libstdcxx is taken from gcc in an ad-hoc way in cc-wrapper.
libcxx = null;
extraPackages = [
targetLlvmLibraries.compiler-rt
];
extraBuildCommands = mkExtraBuildCommands cc;
};
libcxxClang = wrapCCWith rec {
cc = tools.clang-unwrapped;
libcxx = targetLlvmLibraries.libcxx;
extraPackages = [
targetLlvmLibraries.compiler-rt
];
extraBuildCommands = mkExtraBuildCommands cc;
};
lld = callPackage ../common/lld {
src = fetch "lld" "0qg3fgc7wj34hdkqn21y03zcmsdd01szhhm1hfki63iifrm3y2v9";
patches = [
./lld/gnu-install-dirs.patch
];
inherit (libraries) libunwind;
};
lldb = callPackage ../common/lldb.nix {
src = fetch "lldb" "0g3pj1m3chafavpr35r9fynm85y2hdyla6klj0h28khxs2613i78";
patches =
let
resourceDirPatch = callPackage
({ substituteAll, libclang }: substituteAll
{
src = ./lldb/resource-dir.patch;
clangLibDir = "${lib.getLib libclang}/lib";
})
{ };
in
[
./lldb/procfs.patch
resourceDirPatch
./lldb/gnu-install-dirs.patch
];
};
# Below, is the LLVM bootstrapping logic. It handles building a
# fully LLVM toolchain from scratch. No GCC toolchain should be
# pulled in. As a consequence, it is very quick to build different
# targets provided by LLVM and we can also build for what GCC
# doesn’t support like LLVM. Probably we should move to some other
# file.
bintools-unwrapped = callPackage ../common/bintools.nix { };
bintoolsNoLibc = wrapBintoolsWith {
bintools = tools.bintools-unwrapped;
libc = preLibcCrossHeaders;
};
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) [
targetLlvmLibraries.libunwind
];
extraBuildCommands = ''
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;
};
clangWithLibcAndBasicRtAndLibcxx = wrapCCWith rec {
cc = tools.clang-unwrapped;
libcxx = targetLlvmLibraries.libcxx;
bintools = bintools';
extraPackages = [
targetLlvmLibraries.compiler-rt-no-libc
] ++ lib.optionals (!stdenv.targetPlatform.isWasm) [
targetLlvmLibraries.libunwind
];
extraBuildCommands = ''
echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags
echo "-Wno-unused-command-line-argument" >> $out/nix-support/cc-cflags
echo "-B${targetLlvmLibraries.compiler-rt-no-libc}/lib" >> $out/nix-support/cc-cflags
'' + mkExtraBuildCommandsBasicRt cc;
};
clangWithLibcAndBasicRt = wrapCCWith rec {
cc = tools.clang-unwrapped;
libcxx = null;
bintools = bintools';
extraPackages = [
targetLlvmLibraries.compiler-rt-no-libc
];
extraBuildCommands = ''
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;
};
clangNoLibcWithBasicRt = wrapCCWith rec {
cc = tools.clang-unwrapped;
libcxx = null;
bintools = bintoolsNoLibc';
extraPackages = [
targetLlvmLibraries.compiler-rt-no-libc
];
extraBuildCommands = ''
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 = tools.clang-unwrapped;
libcxx = null;
bintools = bintoolsNoLibc';
extraPackages = [ ];
extraBuildCommands = ''
echo "-nostartfiles" >> $out/nix-support/cc-cflags
'' + mkExtraBuildCommands0 cc;
};
# 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;
};
# Aliases
clangNoCompilerRt = tools.clangNoLibcNoRt;
clangNoLibc = tools.clangNoLibcWithBasicRt;
clangNoLibcxx = tools.clangWithLibcAndBasicRt;
});
libraries = lib.makeExtensible (libraries: let
callPackage = newScope (libraries // buildLlvmTools // args // metadata);
in {
compiler-rt-libc = callPackage ../common/compiler-rt (let
stdenv =
if args.stdenv.hostPlatform.useLLVM or false then
overrideCC args.stdenv buildLlvmTools.clangWithLibcAndBasicRtAndLibcxx
else
args.stdenv;
in {
src = fetch "compiler-rt" "1950rg294izdwkaasi7yjrmadc9mzdd5paf0q63jjcq2m3rdbj5l";
patches = [
../common/compiler-rt/7-12-codesign.patch # Revert compiler-rt commit that makes codesign mandatory
./compiler-rt/X86-support-extension.patch # Add support for i486 i586 i686 by reusing i386 config
./compiler-rt/gnu-install-dirs.patch
# ld-wrapper dislikes `-rpath-link //nix/store`, so we normalize away the
# extra `/`.
./compiler-rt/normalize-var.patch
../common/compiler-rt/darwin-plistbuddy-workaround.patch
./compiler-rt/armv7l.patch
# Fix build on armv6l
../common/compiler-rt/armv6-mcr-dmb.patch
../common/compiler-rt/armv6-sync-ops-no-thumb.patch
../common/compiler-rt/armv6-no-ldrexd-strexd.patch
];
inherit stdenv;
} // lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) {
libxcrypt = (libxcrypt.override { inherit stdenv; }).overrideAttrs (old: {
configureFlags = old.configureFlags ++ [ "--disable-symvers" ];
});
});
compiler-rt-no-libc = callPackage ../common/compiler-rt {
src = fetch "compiler-rt" "1950rg294izdwkaasi7yjrmadc9mzdd5paf0q63jjcq2m3rdbj5l";
patches = [
../common/compiler-rt/7-12-codesign.patch # Revert compiler-rt commit that makes codesign mandatory
./compiler-rt/X86-support-extension.patch # Add support for i486 i586 i686 by reusing i386 config
./compiler-rt/gnu-install-dirs.patch
# ld-wrapper dislikes `-rpath-link //nix/store`, so we normalize away the
# extra `/`.
./compiler-rt/normalize-var.patch
../common/compiler-rt/darwin-plistbuddy-workaround.patch
./compiler-rt/armv7l.patch
# Fix build on armv6l
../common/compiler-rt/armv6-mcr-dmb.patch
../common/compiler-rt/armv6-sync-ops-no-thumb.patch
../common/compiler-rt/armv6-no-ldrexd-strexd.patch
];
stdenv =
if stdenv.hostPlatform.isDarwin && stdenv.hostPlatform == stdenv.buildPlatform then
stdenv
else
# TODO: make this branch unconditional next rebuild
overrideCC stdenv buildLlvmTools.clangNoLibcNoRt;
};
compiler-rt =
# 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.
if stdenv.hostPlatform.libc == null || stdenv.hostPlatform.isWasm then
libraries.compiler-rt-no-libc
else
libraries.compiler-rt-libc;
stdenv = overrideCC stdenv buildLlvmTools.clang;
libcxxStdenv = overrideCC stdenv buildLlvmTools.libcxxClang;
libcxx = callPackage ../common/libcxx {
src = fetchFromGitHub {
owner = "llvm";
repo = "llvm-project";
rev = "refs/tags/llvmorg-${metadata.version}";
sparseCheckout = [
"libcxx"
"libcxxabi"
"llvm/cmake"
"llvm/utils"
"runtimes"
];
hash = "sha256-etxgXIdWxMTmbZ83Hsc0w6Jt5OSQSUEPVEWqLkHsNBY=";
};
patches = [
(substitute {
src = ../common/libcxxabi/wasm.patch;
substitutions = [
"--replace-fail" "/cmake/" "/llvm/cmake/"
];
})
] ++ lib.optionals stdenv.hostPlatform.isMusl [
(substitute {
src = ../common/libcxx/libcxx-0001-musl-hacks.patch;
substitutions = [
"--replace-fail" "/include/" "/libcxx/include/"
];
})
];
stdenv = overrideCC stdenv buildLlvmTools.clangWithLibcAndBasicRt;
};
libunwind = callPackage ../common/libunwind {
src = fetch "libunwind" "192ww6n81lj2mb9pj4043z79jp3cf58a9c2qrxjwm5c3a64n1shb";
patches = [
./libunwind/gnu-install-dirs.patch
];
stdenv = overrideCC stdenv buildLlvmTools.clangWithLibcAndBasicRt;
};
openmp = callPackage ../common/openmp {
src = fetch "openmp" "14dh0r6h2xh747ffgnsl4z08h0ri04azi9vf79cbz7ma1r27kzk0";
patches = [
# Fix cross.
(fetchpatch {
url = "https://github.com/llvm/llvm-project/commit/5e2358c781b85a18d1463fd924d2741d4ae5e42e.patch";
hash = "sha256-UxIlAifXnexF/MaraPW0Ut6q+sf3e7y1fMdEv1q103A=";
})
];
};
});
noExtend = extensible: lib.attrsets.removeAttrs extensible [ "extend" ];
in { inherit tools libraries; inherit (metadata) release_version; } // (noExtend libraries) // (noExtend tools)

34
pkgs/development/compilers/llvm/common/clang/default.nix
View File

@ -16,7 +16,6 @@
, buildLlvmTools
, fixDarwinDylibNames
, enableManpages ? false
, clang-tools-extra_src ? null
, devExtraCmakeFlags ? []
}:
@ -38,8 +37,7 @@ let
src = src';
sourceRoot = if lib.versionOlder release_version "13" then null
else "${src.name}/${pname}";
sourceRoot = "${src.name}/${pname}";
nativeBuildInputs = [ cmake ]
++ (lib.optional (lib.versionAtLeast release_version "15") ninja)
@ -79,17 +77,12 @@ let
# Make sure clang passes the correct location of libLTO to ld64
substituteInPlace lib/Driver/ToolChains/Darwin.cpp \
--replace-fail 'StringRef P = llvm::sys::path::parent_path(D.Dir);' 'StringRef P = "${lib.getLib libllvm}";'
'' + (
# See the comment on the `add-nostdlibinc-flag.patch` patch in
# `../default.nix` for why we skip Darwin here.
if lib.versionOlder release_version "13" && (!stdenv.hostPlatform.isDarwin || !stdenv.targetPlatform.isDarwin) then ''
sed -i -e 's/DriverArgs.hasArg(options::OPT_nostdlibinc)/true/' \
-e 's/Args.hasArg(options::OPT_nostdlibinc)/true/' \
lib/Driver/ToolChains/*.cpp
'' else ''
(cd tools && ln -s ../../clang-tools-extra extra)
''
) + lib.optionalString stdenv.hostPlatform.isMusl ''
(cd tools && ln -s ../../clang-tools-extra extra)
'' + lib.optionalString (lib.versionOlder release_version "13") ''
substituteInPlace tools/extra/clangd/quality/CompletionModel.cmake \
--replace ' ''${CMAKE_SOURCE_DIR}/../clang-tools-extra' ' ''${CMAKE_SOURCE_DIR}/tools/extra'
''
+ lib.optionalString stdenv.hostPlatform.isMusl ''
sed -i -e 's/lgcc_s/lgcc_eh/' lib/Driver/ToolChains/*.cpp
'';
@ -215,18 +208,7 @@ let
'';
} else {
ninjaFlags = [ "docs-clang-man" ];
})) // (lib.optionalAttrs (clang-tools-extra_src != null) { inherit clang-tools-extra_src; })
// (lib.optionalAttrs (lib.versionOlder release_version "13") {
unpackPhase = ''
unpackFile $src
mv clang-* clang
sourceRoot=$PWD/clang
unpackFile ${clang-tools-extra_src}
mv clang-tools-extra-* $sourceRoot/tools/extra
substituteInPlace $sourceRoot/tools/extra/clangd/quality/CompletionModel.cmake \
--replace ' ''${CMAKE_SOURCE_DIR}/../clang-tools-extra' ' ''${CMAKE_SOURCE_DIR}/tools/extra'
'';
})
}))
// (lib.optionalAttrs (lib.versionAtLeast release_version "15") {
env = lib.optionalAttrs (stdenv.buildPlatform != stdenv.hostPlatform && !stdenv.hostPlatform.useLLVM) {
# The following warning is triggered with (at least) gcc >=

3
pkgs/development/compilers/llvm/common/compiler-rt/default.nix
View File

@ -73,8 +73,7 @@ stdenv.mkDerivation ({
inherit pname version patches;
src = src';
sourceRoot = if lib.versionOlder release_version "13" then null
else "${src'.name}/${baseName}";
sourceRoot = "${src'.name}/${baseName}";
nativeBuildInputs = [ cmake ]
++ (lib.optional (lib.versionAtLeast release_version "15") ninja)

41
pkgs/development/compilers/llvm/common/default.nix
View File

@ -380,6 +380,17 @@ let
libllvm = callPackage ./llvm {
patches =
lib.optional (lib.versionOlder metadata.release_version "14") ./llvm/llvm-config-link-static.patch
++ lib.optionals (lib.versions.major metadata.release_version == "12") [
(metadata.getVersionFile "llvm/fix-llvm-issue-49955.patch")
# On older CPUs (e.g. Hydra/wendy) we'd be getting an error in this test.
(fetchpatch {
name = "uops-CMOV16rm-noreg.diff";
url = "https://github.com/llvm/llvm-project/commit/9e9f991ac033.diff";
sha256 = "sha256:12s8vr6ibri8b48h2z38f3afhwam10arfiqfy4yg37bmc054p5hi";
stripLen = 1;
})
]
++ [ (metadata.getVersionFile "llvm/gnu-install-dirs.patch") ]
++ lib.optionals (lib.versionAtLeast metadata.release_version "15") [
# Running the tests involves invoking binaries (like `opt`) that depend on
@ -443,7 +454,7 @@ let
hash = "sha256-XPbvNJ45SzjMGlNUgt/IgEvM2dHQpDOe6woUJY+nUYA=";
}
)
++ lib.optionals (lib.versions.major metadata.release_version == "13") [
++ lib.optionals (lib.versionOlder metadata.release_version "14") [
# Backport gcc-13 fixes with missing includes.
(fetchpatch {
name = "signals-gcc-13.patch";
@ -713,8 +724,12 @@ let
#
# See here for some context:
# https://github.com/NixOS/nixpkgs/pull/194634#issuecomment-1272129132
#
# Patch is applied for >= 14 as the versions below are broken anyways.
++ lib.optional (
stdenv.targetPlatform.isDarwin && lib.versionOlder stdenv.targetPlatform.darwinSdkVersion "11.0"
lib.versionAtLeast metadata.release_version "14"
&& stdenv.targetPlatform.isDarwin
&& lib.versionOlder stdenv.targetPlatform.darwinSdkVersion "11.0"
) (metadata.getVersionFile "lldb/cpu_subtype_arm64e_replacement.patch");
}
// lib.optionalAttrs (lib.versions.major metadata.release_version == "16") {
@ -992,7 +1007,10 @@ let
(metadata.getVersionFile "compiler-rt/X86-support-extension.patch") # Add support for i486 i586 i686 by reusing i386 config
]
++ lib.optional (
lib.versionAtLeast metadata.release_version "14" && lib.versionOlder metadata.release_version "18"
lib.versions.major metadata.release_version == "12"
|| (
lib.versionAtLeast metadata.release_version "14" && lib.versionOlder metadata.release_version "18"
)
) (metadata.getVersionFile "compiler-rt/gnu-install-dirs.patch")
++ [
# ld-wrapper dislikes `-rpath-link //nix/store`, so we normalize away the
@ -1000,9 +1018,11 @@ let
(metadata.getVersionFile "compiler-rt/normalize-var.patch")
]
++
lib.optional (lib.versionOlder metadata.release_version "18")
lib.optional
(lib.versionAtLeast metadata.release_version "13" && lib.versionOlder metadata.release_version "18")
# Prevent a compilation error on darwin
(metadata.getVersionFile "compiler-rt/darwin-targetconditionals.patch")
# TODO: make unconditional and remove in <15 section below. Causes rebuilds.
++ lib.optionals (lib.versionAtLeast metadata.release_version "15") [
# See: https://github.com/NixOS/nixpkgs/pull/186575
./compiler-rt/darwin-plistbuddy-workaround.patch
@ -1018,13 +1038,18 @@ let
./compiler-rt/armv6-mcr-dmb.patch
./compiler-rt/armv6-sync-ops-no-thumb.patch
]
++ lib.optionals (lib.versionOlder metadata.release_version "18") [
# Fix build on armv6l
./compiler-rt/armv6-scudo-no-yield.patch
]
++
lib.optionals
(lib.versionAtLeast metadata.release_version "13" && lib.versionOlder metadata.release_version "18")
[
# Fix build on armv6l
./compiler-rt/armv6-scudo-no-yield.patch
]
++ [
# Fix build on armv6l
./compiler-rt/armv6-no-ldrexd-strexd.patch
]
++ lib.optionals (lib.versionAtLeast metadata.release_version "13") [
(metadata.getVersionFile "compiler-rt/armv6-scudo-libatomic.patch")
]
++ lib.optional (lib.versionAtLeast metadata.release_version "19") (fetchpatch {

6
pkgs/development/compilers/llvm/common/libcxx/default.nix
View File

@ -105,9 +105,13 @@ let
cmakeFlags = [
"-DLLVM_ENABLE_RUNTIMES=${lib.concatStringsSep ";" runtimes}"
] ++ lib.optionals (
stdenv.hostPlatform.isWasm
|| (lib.versions.major release_version == "12" && stdenv.hostPlatform.isDarwin)
) [
"-DCMAKE_CXX_COMPILER_WORKS=ON"
] ++ lib.optionals stdenv.hostPlatform.isWasm [
"-DCMAKE_C_COMPILER_WORKS=ON"
"-DCMAKE_CXX_COMPILER_WORKS=ON"
"-DUNIX=ON" # Required otherwise libc++ fails to detect the correct linker
] ++ cxxCMakeFlags
++ lib.optionals (cxxabi == null) cxxabiCMakeFlags

15
pkgs/development/compilers/llvm/common/libunwind/default.nix
View File

@ -35,11 +35,6 @@ let
hasPatches = builtins.length patches > 0;
postUnpack = lib.optionalString (lib.versions.major release_version == "12") ''
ln -s ${libcxx.src}/libcxx .
ln -s ${libcxx.src}/llvm .
'';
prePatch = lib.optionalString (lib.versionAtLeast release_version "15" && (hasPatches || lib.versionOlder release_version "18")) ''
cd ../${pname}
chmod -R u+w .
@ -60,8 +55,8 @@ stdenv.mkDerivation (rec {
src = src';
sourceRoot =
if lib.versionOlder release_version "13" then null
else if lib.versionAtLeast release_version "15" then "${src.name}/runtimes"
if lib.versionAtLeast release_version "15"
then "${src.name}/runtimes"
else "${src.name}/${pname}";
outputs = [ "out" "dev" ];
@ -72,6 +67,9 @@ stdenv.mkDerivation (rec {
cmakeFlags = lib.optional (lib.versionAtLeast release_version "15") "-DLLVM_ENABLE_RUNTIMES=libunwind"
++ lib.optional (!enableShared) "-DLIBUNWIND_ENABLE_SHARED=OFF"
++ lib.optionals (lib.versions.major release_version == "12" && stdenv.hostPlatform.isDarwin) [
"-DCMAKE_CXX_COMPILER_WORKS=ON"
]
++ devExtraCmakeFlags;
meta = llvm_meta // {
@ -85,7 +83,6 @@ stdenv.mkDerivation (rec {
dependency of other runtimes.
'';
};
} // (if postUnpack != "" then { inherit postUnpack; } else {})
// (if (lib.versionAtLeast release_version "15") then { inherit postInstall; } else {})
} // (if (lib.versionAtLeast release_version "15") then { inherit postInstall; } else {})
// (if prePatch != "" then { inherit prePatch; } else {})
// (if postPatch != "" then { inherit postPatch; } else {}))

12
pkgs/development/compilers/llvm/common/lld/default.nix
View File

@ -6,7 +6,6 @@
, buildLlvmTools
, monorepoSrc ? null
, src ? null
, libunwind ? null
, runCommand
, cmake
, ninja
@ -30,12 +29,7 @@ let
mkdir -p "$out/llvm"
'') else src;
postPatch = lib.optionalString (lib.versions.major release_version == "12") ''
substituteInPlace MachO/CMakeLists.txt --replace \
'(''${LLVM_MAIN_SRC_DIR}/' '('
mkdir -p libunwind/include
tar -xf "${libunwind.src}" --wildcards -C libunwind/include --strip-components=2 "libunwind-*/include/"
'' + lib.optionalString (lib.versions.major release_version == "13") ''
postPatch = lib.optionalString (lib.versionOlder release_version "14") ''
substituteInPlace MachO/CMakeLists.txt --replace \
'(''${LLVM_MAIN_SRC_DIR}/' '(../'
'';
@ -45,9 +39,7 @@ stdenv.mkDerivation (rec {
src = src';
sourceRoot =
if lib.versionOlder release_version "13" then null
else "${src.name}/${pname}";
sourceRoot = "${src.name}/${pname}";
nativeBuildInputs = [ cmake ] ++ lib.optional (lib.versionAtLeast release_version "15") ninja;
buildInputs = [ libllvm libxml2 ];

17
pkgs/development/compilers/llvm/common/llvm/default.nix
View File

@ -4,7 +4,6 @@
, pkgsBuildBuild
, pollyPatches ? []
, patches ? []
, polly_src ? null
, src ? null
, monorepoSrc ? null
, runCommand
@ -107,8 +106,7 @@ stdenv.mkDerivation (finalAttrs: {
src = src';
patches = patches';
sourceRoot = if lib.versionOlder release_version "13" then null
else "${finalAttrs.src.name}/${pname}";
sourceRoot = "${finalAttrs.src.name}/${pname}";
outputs = [ "out" "lib" "dev" "python" ];
@ -493,18 +491,7 @@ stdenv.mkDerivation (finalAttrs: {
postPatch = null;
postInstall = null;
})) // lib.optionalAttrs (lib.versionOlder release_version "13") {
inherit polly_src;
unpackPhase = ''
unpackFile $src
mv llvm-${release_version}* llvm
sourceRoot=$PWD/llvm
'' + optionalString enablePolly ''
unpackFile $polly_src
mv polly-* $sourceRoot/tools/polly
'';
} // lib.optionalAttrs (lib.versionAtLeast release_version "13") {
})) // lib.optionalAttrs (lib.versionAtLeast release_version "13") {
nativeCheckInputs = [ which ] ++ lib.optional (stdenv.hostPlatform.isDarwin && lib.versionAtLeast release_version "15") sysctl;
} // lib.optionalAttrs (lib.versionOlder release_version "15") {
# hacky fix: created binaries need to be run before installation

4
pkgs/development/compilers/llvm/common/openmp/default.nix
View File

@ -34,9 +34,7 @@ stdenv.mkDerivation (rec {
src = src';
sourceRoot =
if lib.versionOlder release_version "13" then null
else "${src.name}/${pname}";
sourceRoot = "${src.name}/${pname}";
outputs = [ "out" ]
++ lib.optionals (lib.versionAtLeast release_version "14") [ "dev" ];

1
pkgs/development/compilers/llvm/default.nix
View File

@ -22,6 +22,7 @@
}@packageSetArgs:
let
versions = {
"12.0.1".officialRelease.sha256 = "08s5w2db9imb2yaqsvxs6pg21csi1cf6wa35rf8x6q07mam7j8qv";
"13.0.1".officialRelease.sha256 = "06dv6h5dmvzdxbif2s8njki6h32796v368dyb5945x8gjj72xh7k";
"14.0.6".officialRelease.sha256 = "sha256-vffu4HilvYwtzwgq+NlS26m65DGbp6OSSne2aje1yJE=";
"15.0.7".officialRelease.sha256 = "sha256-wjuZQyXQ/jsmvy6y1aksCcEDXGBjuhpgngF3XQJ/T4s=";

11
pkgs/top-level/all-packages.nix
View File

@ -6769,16 +6769,10 @@ with pkgs;
stdenv.targetPlatform));
in pkgs.${"llvmPackages_${minSupported}"};
llvmPackages_12 = recurseIntoAttrs (callPackage ../development/compilers/llvm/12 {
inherit (stdenvAdapters) overrideCC;
buildLlvmTools = buildPackages.llvmPackages_12.tools;
targetLlvmLibraries = targetPackages.llvmPackages_12.libraries or llvmPackages_12.libraries;
targetLlvm = targetPackages.llvmPackages_12.llvm or llvmPackages_12.llvm;
});
inherit (rec {
llvmPackagesSet = recurseIntoAttrs (callPackages ../development/compilers/llvm { });
llvmPackages_12 = llvmPackagesSet."12";
llvmPackages_13 = llvmPackagesSet."13";
llvmPackages_14 = llvmPackagesSet."14";
llvmPackages_15 = llvmPackagesSet."15";
@ -6797,7 +6791,8 @@ with pkgs;
lldb_19 = llvmPackages_19.lldb;
llvm_19 = llvmPackages_19.llvm;
bolt_19 = llvmPackages_19.bolt;
}) llvmPackages_13
}) llvmPackages_12
llvmPackages_13
llvmPackages_14
llvmPackages_15
llvmPackages_16