1350 lines
45 KiB
Nix
1350 lines
45 KiB
Nix
# This file contains the standard build environment for Darwin. It is based on LLVM and is patterned
|
||
# after the Linux stdenv. It shares similar goals to the Linux standard environment in that the
|
||
# resulting environment should be built purely and not contain any references to it.
|
||
#
|
||
# For more on the design of the stdenv and updating it, see `README.md`.
|
||
#
|
||
# See also the top comments of the Linux stdenv `../linux/default.nix` for a good overview of
|
||
# the bootstrap process and working with it.
|
||
|
||
{
|
||
lib,
|
||
localSystem,
|
||
crossSystem,
|
||
config,
|
||
overlays,
|
||
crossOverlays ? [ ],
|
||
# Allow passing in bootstrap files directly so we can test the stdenv bootstrap process when changing the bootstrap tools
|
||
bootstrapFiles ? (config.replaceBootstrapFiles or lib.id) (
|
||
if localSystem.isAarch64 then
|
||
import ./bootstrap-files/aarch64-apple-darwin.nix
|
||
else
|
||
import ./bootstrap-files/x86_64-apple-darwin.nix
|
||
),
|
||
}:
|
||
|
||
assert crossSystem == localSystem;
|
||
|
||
let
|
||
inherit (localSystem) system;
|
||
|
||
sdkMajorVersion =
|
||
let
|
||
inherit (localSystem) darwinSdkVersion;
|
||
in
|
||
if lib.versionOlder darwinSdkVersion "11" then
|
||
lib.versions.majorMinor darwinSdkVersion
|
||
else
|
||
lib.versions.major darwinSdkVersion;
|
||
|
||
commonImpureHostDeps = [
|
||
"/bin/sh"
|
||
"/usr/lib/libSystem.B.dylib"
|
||
"/usr/lib/system/libunc.dylib" # This dependency is "hidden", so our scanning code doesn't pick it up
|
||
];
|
||
|
||
isFromNixpkgs = pkg: !(isFromBootstrapFiles pkg);
|
||
isFromBootstrapFiles = pkg: pkg.passthru.isFromBootstrapFiles or false;
|
||
isBuiltByNixpkgsCompiler = pkg: isFromNixpkgs pkg && isFromNixpkgs pkg.stdenv.cc.cc;
|
||
isBuiltByBootstrapFilesCompiler = pkg: isFromNixpkgs pkg && isFromBootstrapFiles pkg.stdenv.cc.cc;
|
||
|
||
# Dependencies in dependency sets should be mutually exclusive.
|
||
mergeDisjointAttrs = lib.foldl' lib.attrsets.unionOfDisjoint { };
|
||
|
||
commonPreHook = ''
|
||
export NIX_ENFORCE_NO_NATIVE=''${NIX_ENFORCE_NO_NATIVE-1}
|
||
export NIX_ENFORCE_PURITY=''${NIX_ENFORCE_PURITY-1}
|
||
export NIX_IGNORE_LD_THROUGH_GCC=1
|
||
'';
|
||
|
||
bootstrapTools =
|
||
derivation (
|
||
{
|
||
inherit system;
|
||
|
||
name = "bootstrap-tools";
|
||
builder = "${bootstrapFiles.unpack}/bin/bash";
|
||
|
||
args = [
|
||
"${bootstrapFiles.unpack}/bootstrap-tools-unpack.sh"
|
||
bootstrapFiles.bootstrapTools
|
||
];
|
||
|
||
PATH = lib.makeBinPath [
|
||
(placeholder "out")
|
||
bootstrapFiles.unpack
|
||
];
|
||
|
||
__impureHostDeps = commonImpureHostDeps;
|
||
}
|
||
// lib.optionalAttrs config.contentAddressedByDefault {
|
||
__contentAddressed = true;
|
||
outputHashAlgo = "sha256";
|
||
outputHashMode = "recursive";
|
||
}
|
||
)
|
||
// {
|
||
passthru.isFromBootstrapFiles = true;
|
||
};
|
||
|
||
stageFun =
|
||
prevStage:
|
||
{
|
||
name,
|
||
overrides ? (self: super: { }),
|
||
extraNativeBuildInputs ? [ ],
|
||
extraPreHook ? "",
|
||
}:
|
||
|
||
let
|
||
cc =
|
||
if prevStage.llvmPackages.clang-unwrapped == null then
|
||
null
|
||
else
|
||
prevStage.wrapCCWith {
|
||
name = "${name}-clang-wrapper";
|
||
|
||
nativeTools = false;
|
||
nativeLibc = false;
|
||
|
||
expand-response-params = lib.optionalString (
|
||
prevStage.stdenv.hasCC or false && prevStage.stdenv.cc != "/dev/null"
|
||
) prevStage.expand-response-params;
|
||
|
||
extraPackages = [ prevStage.llvmPackages.compiler-rt ];
|
||
|
||
extraBuildCommands =
|
||
let
|
||
inherit (prevStage.llvmPackages) clang-unwrapped compiler-rt;
|
||
in
|
||
''
|
||
function clangResourceRootIncludePath() {
|
||
clangLib="$1/lib/clang"
|
||
if (( $(ls "$clangLib" | wc -l) > 1 )); then
|
||
echo "Multiple LLVM versions were found at "$clangLib", but there must only be one used when building the stdenv." >&2
|
||
exit 1
|
||
fi
|
||
echo "$clangLib/$(ls -1 "$clangLib")/include"
|
||
}
|
||
|
||
rsrc="$out/resource-root"
|
||
mkdir "$rsrc"
|
||
ln -s "$(clangResourceRootIncludePath "${lib.getLib clang-unwrapped}")" "$rsrc"
|
||
ln -s "${compiler-rt.out}/lib" "$rsrc/lib"
|
||
ln -s "${compiler-rt.out}/share" "$rsrc/share"
|
||
echo "-resource-dir=$rsrc" >> $out/nix-support/cc-cflags
|
||
''
|
||
+ lib.optionalString (isFromBootstrapFiles prevStage.llvmPackages.clang-unwrapped) ''
|
||
# Work around the `-nostdlibinc` patch in the bootstrap tools.
|
||
# TODO: Remove after the bootstrap tools have been updated.
|
||
substituteAll ${builtins.toFile "add-flags-extra.sh" ''
|
||
if [ "@darwinMinVersion@" ]; then
|
||
NIX_CFLAGS_COMPILE_@suffixSalt@+=" -idirafter $SDKROOT/usr/include"
|
||
NIX_CFLAGS_COMPILE_@suffixSalt@+=" -iframework $SDKROOT/System/Library/Frameworks"
|
||
fi
|
||
''} add-flags-extra.sh
|
||
cat add-flags-extra.sh >> $out/nix-support/add-flags.sh
|
||
'';
|
||
|
||
cc = prevStage.llvmPackages.clang-unwrapped;
|
||
bintools = prevStage.darwin.binutils;
|
||
|
||
isClang = true;
|
||
libc = prevStage.darwin.libSystem;
|
||
inherit (prevStage.llvmPackages) libcxx;
|
||
|
||
inherit lib;
|
||
inherit (prevStage) coreutils gnugrep;
|
||
|
||
stdenvNoCC = prevStage.ccWrapperStdenv;
|
||
runtimeShell = prevStage.ccWrapperStdenv.shell;
|
||
};
|
||
|
||
bash = prevStage.bash or bootstrapTools;
|
||
|
||
thisStdenv = import ../generic {
|
||
name = "${name}-stdenv-darwin";
|
||
|
||
buildPlatform = localSystem;
|
||
hostPlatform = localSystem;
|
||
targetPlatform = localSystem;
|
||
|
||
inherit config;
|
||
|
||
extraBuildInputs = [ prevStage.apple-sdk ];
|
||
inherit extraNativeBuildInputs;
|
||
|
||
preHook =
|
||
lib.optionalString (!isBuiltByNixpkgsCompiler bash) ''
|
||
# Don't patch #!/interpreter because it leads to retained
|
||
# dependencies on the bootstrapTools in the final stdenv.
|
||
dontPatchShebangs=1
|
||
''
|
||
+ ''
|
||
${commonPreHook}
|
||
${extraPreHook}
|
||
''
|
||
+ lib.optionalString (prevStage.darwin ? locale) ''
|
||
export PATH_LOCALE=${prevStage.darwin.locale}/share/locale
|
||
'';
|
||
|
||
shell = bash + "/bin/bash";
|
||
initialPath = [
|
||
bash
|
||
prevStage.file
|
||
bootstrapTools
|
||
];
|
||
|
||
fetchurlBoot = import ../../build-support/fetchurl {
|
||
inherit lib;
|
||
stdenvNoCC = prevStage.ccWrapperStdenv or thisStdenv;
|
||
curl = bootstrapTools;
|
||
};
|
||
|
||
inherit cc;
|
||
|
||
# The stdenvs themselves don't use mkDerivation, so I need to specify this here
|
||
__stdenvImpureHostDeps = commonImpureHostDeps;
|
||
__extraImpureHostDeps = commonImpureHostDeps;
|
||
|
||
# Using the bootstrap tools curl for fetchers allows the stdenv bootstrap to avoid
|
||
# having a dependency on curl, allowing curl to be updated without triggering a
|
||
# new stdenv bootstrap on Darwin.
|
||
overrides =
|
||
self: super:
|
||
(overrides self super)
|
||
// {
|
||
fetchurl = thisStdenv.fetchurlBoot;
|
||
fetchpatch = super.fetchpatch.override { inherit (self) fetchurl; };
|
||
fetchzip = super.fetchzip.override { inherit (self) fetchurl; };
|
||
};
|
||
};
|
||
|
||
in
|
||
{
|
||
inherit config overlays;
|
||
stdenv = thisStdenv;
|
||
};
|
||
|
||
# Dependencies - these are packages that are rebuilt together in groups. Defining them here ensures they are
|
||
# asserted and overlayed together. It also removes a lot of clutter from the stage definitions.
|
||
#
|
||
# When multiple dependency sets share a dependency, it should be put in the one that will be (re)built first.
|
||
# That makes sure everything else will share the same dependency in the final stdenv.
|
||
|
||
allDeps =
|
||
checkFn: sets:
|
||
let
|
||
sets' = mergeDisjointAttrs sets;
|
||
result = lib.all checkFn (lib.attrValues sets');
|
||
resultDetails = lib.mapAttrs (_: checkFn) sets';
|
||
in
|
||
lib.traceIf (!result) (lib.deepSeq resultDetails resultDetails) result;
|
||
|
||
# These packages are built in stage 1 then never built again. They must not be included in the final overlay
|
||
# or as dependencies to packages that are in the final overlay. They are mostly tools used as native build inputs.
|
||
# Any libraries in the list must only be used as dependencies of packages in this list.
|
||
stage1Packages = prevStage: {
|
||
inherit (prevStage)
|
||
atf
|
||
autoconf
|
||
automake
|
||
bison
|
||
bmake
|
||
brotli
|
||
cmake
|
||
cpio
|
||
cyrus_sasl
|
||
ed
|
||
expat
|
||
flex
|
||
gettext
|
||
groff
|
||
jq
|
||
kyua
|
||
libedit
|
||
libtool
|
||
m4
|
||
meson
|
||
ninja
|
||
openldap
|
||
openssh
|
||
patchutils
|
||
pbzx
|
||
perl
|
||
pkg-config
|
||
python3
|
||
python3Minimal
|
||
scons
|
||
serf
|
||
sqlite
|
||
subversion
|
||
texinfo
|
||
unzip
|
||
which
|
||
;
|
||
};
|
||
|
||
# These packages include both the core bintools (other than LLVM) packages as well as their dependencies.
|
||
bintoolsPackages = prevStage: {
|
||
inherit (prevStage)
|
||
cctools
|
||
ld64
|
||
bzip2
|
||
coreutils
|
||
gmp
|
||
gnugrep
|
||
libtapi
|
||
openssl
|
||
pcre2
|
||
xar
|
||
xz
|
||
;
|
||
};
|
||
|
||
darwinPackages = prevStage: { inherit (prevStage.darwin) sigtool; };
|
||
darwinPackagesNoCC = prevStage: {
|
||
inherit (prevStage.darwin)
|
||
binutils
|
||
binutils-unwrapped
|
||
libSystem
|
||
locale
|
||
;
|
||
};
|
||
|
||
# These packages are not allowed to be used in the Darwin bootstrap
|
||
disallowedPackages = prevStage: { inherit (prevStage) binutils-unwrapped curl; };
|
||
|
||
# LLVM tools packages are staged separately (xclang, stage3) from LLVM libs (xclang).
|
||
llvmLibrariesPackages = prevStage: { inherit (prevStage.llvmPackages) compiler-rt libcxx; };
|
||
llvmLibrariesDeps = _: { };
|
||
|
||
llvmToolsPackages = prevStage: {
|
||
inherit (prevStage.llvmPackages)
|
||
clang-unwrapped
|
||
libclang
|
||
libllvm
|
||
lld
|
||
llvm
|
||
llvm-manpages
|
||
;
|
||
};
|
||
|
||
llvmToolsDeps = prevStage: { inherit (prevStage) libffi; };
|
||
|
||
# SDK packages include propagated packages and source release packages built during the bootstrap.
|
||
sdkPackages = prevStage: {
|
||
inherit (prevStage)
|
||
bash
|
||
libpng
|
||
libxml2
|
||
libxo
|
||
ncurses
|
||
openbsm
|
||
openpam
|
||
xcbuild
|
||
zlib
|
||
;
|
||
};
|
||
sdkDarwinPackages = prevStage: {
|
||
inherit (prevStage.darwin)
|
||
Csu
|
||
adv_cmds
|
||
copyfile
|
||
libiconv
|
||
libresolv
|
||
libsbuf
|
||
libutil
|
||
system_cmds
|
||
;
|
||
};
|
||
sdkPackagesNoCC = prevStage: { inherit (prevStage) apple-sdk; };
|
||
|
||
in
|
||
assert bootstrapTools.passthru.isFromBootstrapFiles or false; # sanity check
|
||
[
|
||
(
|
||
{ }:
|
||
{
|
||
__raw = true;
|
||
|
||
apple-sdk = null;
|
||
|
||
cctools = null;
|
||
ld64 = null;
|
||
|
||
coreutils = null;
|
||
file = null;
|
||
gnugrep = null;
|
||
|
||
pbzx = null;
|
||
cpio = null;
|
||
|
||
jq = null;
|
||
|
||
darwin = {
|
||
binutils = null;
|
||
binutils-unwrapped = null;
|
||
libSystem = null;
|
||
sigtool = null;
|
||
};
|
||
|
||
llvmPackages = {
|
||
clang-unwrapped = null;
|
||
compiler-rt = null;
|
||
libcxx = null;
|
||
libllvm = null;
|
||
};
|
||
}
|
||
)
|
||
|
||
# Create a stage with the bootstrap tools. This will be used to build the subsequent stages and
|
||
# build up the standard environment.
|
||
#
|
||
# Note: Each stage depends only on the the packages in `prevStage`. If a package is not to be
|
||
# rebuilt, it should be passed through by inheriting it.
|
||
(
|
||
prevStage:
|
||
stageFun prevStage {
|
||
name = "bootstrap-stage0";
|
||
|
||
overrides = self: super: {
|
||
# We thread stage0's stdenv through under this name so downstream stages
|
||
# can use it for wrapping gcc too. This way, downstream stages don't need
|
||
# to refer to this stage directly, which violates the principle that each
|
||
# stage should only access the stage that came before it.
|
||
ccWrapperStdenv = self.stdenv;
|
||
|
||
bash = bootstrapTools // {
|
||
shellPath = "/bin/bash";
|
||
};
|
||
|
||
coreutils = bootstrapTools;
|
||
cpio = bootstrapTools;
|
||
file = null;
|
||
gnugrep = bootstrapTools;
|
||
pbzx = bootstrapTools;
|
||
|
||
jq = null;
|
||
|
||
cctools = bootstrapTools // {
|
||
libtool = bootstrapTools;
|
||
targetPrefix = "";
|
||
version = "boot";
|
||
};
|
||
|
||
ld64 = bootstrapTools // {
|
||
targetPrefix = "";
|
||
version = "boot";
|
||
};
|
||
|
||
darwin = super.darwin.overrideScope (
|
||
selfDarwin: superDarwin: {
|
||
binutils = super.wrapBintoolsWith {
|
||
name = "bootstrap-stage0-binutils-wrapper";
|
||
|
||
nativeTools = false;
|
||
nativeLibc = false;
|
||
|
||
expand-response-params = "";
|
||
libc = selfDarwin.libSystem;
|
||
|
||
inherit lib;
|
||
inherit (self) stdenvNoCC coreutils gnugrep;
|
||
runtimeShell = self.stdenvNoCC.shell;
|
||
|
||
bintools = selfDarwin.binutils-unwrapped;
|
||
|
||
# Bootstrap tools cctools needs the hook and wrappers to make sure things are signed properly,
|
||
# and additional linker flags to work around a since‐removed patch.
|
||
# This can be dropped once the bootstrap tools cctools has been updated to 1010.6.
|
||
extraBuildCommands = ''
|
||
printf %s ${lib.escapeShellArg ''
|
||
extraBefore+=("-F$DEVELOPER_DIR/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks")
|
||
extraBefore+=("-L$DEVELOPER_DIR/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/lib")
|
||
''} >> $out/nix-support/add-local-ldflags-before.sh
|
||
|
||
echo 'source ${selfDarwin.postLinkSignHook}' >> $out/nix-support/post-link-hook
|
||
|
||
export signingUtils=${selfDarwin.signingUtils}
|
||
|
||
wrap \
|
||
install_name_tool ${../../build-support/bintools-wrapper/darwin-install_name_tool-wrapper.sh} \
|
||
"${selfDarwin.binutils-unwrapped}/bin/install_name_tool"
|
||
|
||
wrap \
|
||
strip ${../../build-support/bintools-wrapper/darwin-strip-wrapper.sh} \
|
||
"${selfDarwin.binutils-unwrapped}/bin/strip"
|
||
'';
|
||
};
|
||
|
||
binutils-unwrapped =
|
||
(superDarwin.binutils-unwrapped.override { enableManpages = false; }).overrideAttrs
|
||
(old: {
|
||
version = "boot";
|
||
passthru = (old.passthru or { }) // {
|
||
isFromBootstrapFiles = true;
|
||
};
|
||
});
|
||
|
||
locale = self.stdenv.mkDerivation {
|
||
name = "bootstrap-stage0-locale";
|
||
buildCommand = ''
|
||
mkdir -p $out/share/locale
|
||
'';
|
||
};
|
||
|
||
sigtool = bootstrapTools;
|
||
}
|
||
);
|
||
|
||
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"
|
||
"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}/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
|
||
);
|
||
};
|
||
|
||
extraPreHook = ''
|
||
stripDebugFlags="-S" # llvm-strip does not support "-p" for Mach-O
|
||
'';
|
||
}
|
||
)
|
||
|
||
# This stage is primarily responsible for setting up versions of certain dependencies needed
|
||
# by the rest of the build process. This stage also builds CF and Libsystem to simplify assertions
|
||
# and assumptions for later by making sure both packages are present on x86_64-darwin and aarch64-darwin.
|
||
(
|
||
prevStage:
|
||
# previous stage0 stdenv:
|
||
assert allDeps isFromBootstrapFiles [
|
||
(llvmToolsPackages prevStage)
|
||
(llvmLibrariesPackages prevStage)
|
||
{
|
||
inherit (prevStage)
|
||
bash
|
||
cctools
|
||
coreutils
|
||
cpio
|
||
gnugrep
|
||
ld64
|
||
pbzx
|
||
;
|
||
inherit (prevStage.darwin) binutils-unwrapped sigtool;
|
||
}
|
||
];
|
||
|
||
assert allDeps isFromNixpkgs [
|
||
(sdkPackagesNoCC prevStage)
|
||
{ inherit (prevStage.darwin) binutils libSystem; }
|
||
];
|
||
|
||
stageFun prevStage {
|
||
name = "bootstrap-stage1";
|
||
|
||
overrides = self: super: {
|
||
inherit (prevStage) ccWrapperStdenv cctools ld64;
|
||
|
||
binutils-unwrapped = builtins.throw "nothing in the Darwin bootstrap should depend on GNU binutils";
|
||
curl = builtins.throw "nothing in the Darwin bootstrap can depend on curl";
|
||
|
||
# Use this stage’s CF to build CMake. It’s required but can’t be included in the stdenv.
|
||
cmake = self.cmakeMinimal;
|
||
|
||
# Use libiconvReal with gettext to break an infinite recursion.
|
||
gettext = super.gettext.override { libiconv = super.libiconvReal; };
|
||
|
||
# Disable tests because they use dejagnu, which fails to run.
|
||
libffi = super.libffi.override { doCheck = false; };
|
||
|
||
# Avoid pulling in a full python and its extra dependencies for the llvm/clang builds.
|
||
libxml2 = super.libxml2.override { pythonSupport = false; };
|
||
|
||
# Avoid pulling in openldap just to run Meson’s tests.
|
||
meson = super.meson.overrideAttrs { doInstallCheck = false; };
|
||
ninja = super.ninja.override { buildDocs = false; };
|
||
|
||
# pkg-config builds glib, which checks for `arpa/nameser.h` and fails to build if it can’t find it.
|
||
# libresolv is normally propagated by the SDK, but propagation is disabled early in the bootstrap.
|
||
# Trying to add libresolv as a dependency causes an infinite recursion. Use pkgconf instead.
|
||
pkg-config =
|
||
(super.pkg-config.override {
|
||
pkg-config = self.libpkgconf.override {
|
||
removeReferencesTo = self.removeReferencesTo.override {
|
||
# Avoid an infinite recursion by using the previous stage‘s sigtool.
|
||
signingUtils = prevStage.darwin.signingUtils.override { inherit (prevStage.darwin) sigtool; };
|
||
};
|
||
};
|
||
baseBinName = "pkgconf";
|
||
}).overrideAttrs
|
||
# Passthru the wrapped pkgconf’s stdenv to make the bootstrap assertions happy.
|
||
(
|
||
old: {
|
||
passthru = old.passthru or { } // {
|
||
inherit (self) stdenv;
|
||
};
|
||
}
|
||
);
|
||
|
||
# Use a full Python for the bootstrap. This allows Meson to be built in stage 1 and makes it easier to build
|
||
# packages that have Python dependencies.
|
||
python3 = self.python3-bootstrap;
|
||
python3-bootstrap = super.python3.override {
|
||
self = self.python3-bootstrap;
|
||
pythonAttr = "python3-bootstrap";
|
||
enableLTO = false;
|
||
# Workaround for ld64 crashes on x86_64-darwin. Remove after 11.0 is made the default.
|
||
inherit (prevStage) apple-sdk_11;
|
||
};
|
||
|
||
scons = super.scons.override { python3Packages = self.python3.pkgs; };
|
||
|
||
xar = super.xarMinimal;
|
||
|
||
darwin = super.darwin.overrideScope (
|
||
selfDarwin: superDarwin: {
|
||
signingUtils = prevStage.darwin.signingUtils.override { inherit (selfDarwin) sigtool; };
|
||
|
||
postLinkSignHook = prevStage.darwin.postLinkSignHook.override { inherit (selfDarwin) sigtool; };
|
||
|
||
adv_cmds = superDarwin.adv_cmds.override {
|
||
# Break an infinite recursion between CMake and libtapi. CMake requires adv_cmds.ps, and adv_cmds
|
||
# requires a newer SDK that requires libtapi to build, which requires CMake.
|
||
inherit (prevStage) apple-sdk_11;
|
||
};
|
||
|
||
# Rewrap binutils with the real libSystem
|
||
binutils = superDarwin.binutils.override {
|
||
inherit (self) coreutils;
|
||
bintools = selfDarwin.binutils-unwrapped;
|
||
libc = selfDarwin.libSystem;
|
||
|
||
# Bootstrap tools cctools needs the hook and wrappers to make sure things are signed properly.
|
||
# This can be dropped once the bootstrap tools cctools has been updated to 1010.6.
|
||
extraBuildCommands = ''
|
||
printf %s ${lib.escapeShellArg ''
|
||
extraBefore+=("-F$DEVELOPER_DIR/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks")
|
||
extraBefore+=("-L$DEVELOPER_DIR/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/lib")
|
||
''} >> $out/nix-support/add-local-ldflags-before.sh
|
||
|
||
echo 'source ${selfDarwin.postLinkSignHook}' >> $out/nix-support/post-link-hook
|
||
|
||
export signingUtils=${selfDarwin.signingUtils}
|
||
|
||
wrap \
|
||
install_name_tool ${../../build-support/bintools-wrapper/darwin-install_name_tool-wrapper.sh} \
|
||
"${selfDarwin.binutils-unwrapped}/bin/install_name_tool"
|
||
|
||
wrap \
|
||
strip ${../../build-support/bintools-wrapper/darwin-strip-wrapper.sh} \
|
||
"${selfDarwin.binutils-unwrapped}/bin/strip"
|
||
'';
|
||
};
|
||
|
||
# Avoid building unnecessary Python dependencies due to building LLVM manpages.
|
||
binutils-unwrapped = superDarwin.binutils-unwrapped.override {
|
||
inherit (self) cctools ld64;
|
||
enableManpages = false;
|
||
};
|
||
}
|
||
);
|
||
|
||
llvmPackages =
|
||
let
|
||
tools = super.llvmPackages.tools.extend (_: _: llvmToolsPackages prevStage);
|
||
libraries = super.llvmPackages.libraries.extend (_: _: llvmLibrariesPackages prevStage);
|
||
in
|
||
super.llvmPackages // { inherit tools libraries; } // tools // libraries;
|
||
};
|
||
|
||
extraNativeBuildInputs = lib.optionals localSystem.isAarch64 [
|
||
prevStage.updateAutotoolsGnuConfigScriptsHook
|
||
prevStage.gnu-config
|
||
];
|
||
|
||
extraPreHook = ''
|
||
stripDebugFlags="-S" # llvm-strip does not support "-p" for Mach-O
|
||
'';
|
||
}
|
||
)
|
||
|
||
# First rebuild of LLVM. While this LLVM is linked to a bunch of junk from the bootstrap tools,
|
||
# the compiler-rt, libc++, and libc++abi it produces are not. The compiler will be
|
||
# rebuilt in a later stage, but those libraries will be used in the final stdenv.
|
||
(
|
||
prevStage:
|
||
# previous stage1 stdenv:
|
||
assert allDeps isFromBootstrapFiles [
|
||
(llvmLibrariesPackages prevStage)
|
||
(llvmToolsPackages prevStage)
|
||
{ inherit (prevStage) ld64; }
|
||
];
|
||
|
||
assert allDeps isBuiltByBootstrapFilesCompiler [
|
||
(stage1Packages prevStage)
|
||
(darwinPackages prevStage)
|
||
(llvmLibrariesDeps prevStage)
|
||
(llvmToolsDeps prevStage)
|
||
(sdkPackages prevStage)
|
||
(sdkDarwinPackages prevStage)
|
||
];
|
||
|
||
assert allDeps isFromNixpkgs [
|
||
(darwinPackagesNoCC prevStage)
|
||
(sdkPackagesNoCC prevStage)
|
||
];
|
||
|
||
stageFun prevStage {
|
||
name = "bootstrap-stage-xclang";
|
||
|
||
overrides =
|
||
self: super:
|
||
mergeDisjointAttrs [
|
||
(stage1Packages prevStage)
|
||
(disallowedPackages prevStage)
|
||
# Only cctools and ld64 are rebuilt from `bintoolsPackages` to avoid rebuilding their dependencies
|
||
# again in this stage after building them in stage 1.
|
||
(lib.filterAttrs (name: _: name != "ld64" && name != "cctools") (bintoolsPackages prevStage))
|
||
(llvmToolsDeps prevStage)
|
||
(sdkPackages prevStage)
|
||
(sdkPackagesNoCC prevStage)
|
||
{
|
||
inherit (prevStage) ccWrapperStdenv;
|
||
|
||
# Disable ld64’s install check phase because the required LTO libraries are not built yet.
|
||
ld64 = super.ld64.overrideAttrs { doInstallCheck = false; };
|
||
|
||
darwin = super.darwin.overrideScope (
|
||
selfDarwin: superDarwin:
|
||
darwinPackages prevStage
|
||
// sdkDarwinPackages prevStage
|
||
// {
|
||
inherit (prevStage.darwin) libSystem;
|
||
binutils-unwrapped = superDarwin.binutils-unwrapped.override { enableManpages = false; };
|
||
}
|
||
);
|
||
}
|
||
];
|
||
|
||
extraNativeBuildInputs = lib.optionals localSystem.isAarch64 [
|
||
prevStage.updateAutotoolsGnuConfigScriptsHook
|
||
prevStage.gnu-config
|
||
];
|
||
|
||
extraPreHook = ''
|
||
stripDebugFlags="-S" # llvm-strip does not support "-p" for Mach-O
|
||
'';
|
||
}
|
||
)
|
||
|
||
# This stage rebuilds the SDK. It also rebuilds bash, which will be needed in later stages
|
||
# to use in patched shebangs (e.g., to make sure `icu-config` uses bash from nixpkgs).
|
||
(
|
||
prevStage:
|
||
# previous stage-xclang stdenv:
|
||
assert allDeps isBuiltByBootstrapFilesCompiler [
|
||
(stage1Packages prevStage)
|
||
(bintoolsPackages prevStage)
|
||
(darwinPackages prevStage)
|
||
(llvmToolsDeps prevStage)
|
||
(llvmToolsPackages prevStage)
|
||
(sdkPackages prevStage)
|
||
(sdkDarwinPackages prevStage)
|
||
];
|
||
|
||
assert allDeps isBuiltByNixpkgsCompiler [
|
||
(llvmLibrariesDeps prevStage)
|
||
(llvmLibrariesPackages prevStage)
|
||
];
|
||
|
||
assert allDeps isFromNixpkgs [
|
||
(darwinPackagesNoCC prevStage)
|
||
(sdkPackagesNoCC prevStage)
|
||
];
|
||
|
||
stageFun prevStage {
|
||
name = "bootstrap-stage2";
|
||
|
||
overrides =
|
||
self: super:
|
||
mergeDisjointAttrs [
|
||
(stage1Packages prevStage)
|
||
(disallowedPackages prevStage)
|
||
(bintoolsPackages prevStage)
|
||
(llvmLibrariesDeps prevStage)
|
||
(llvmToolsDeps prevStage)
|
||
{
|
||
inherit (prevStage) ccWrapperStdenv;
|
||
|
||
# Avoid an infinite recursion due to the SDK’s including ncurses, which depends on bash in its `dev` output.
|
||
bash = super.bash.override { stdenv = self.darwin.bootstrapStdenv; };
|
||
|
||
# Avoid pulling in a full python and its extra dependencies for the llvm/clang builds.
|
||
libxml2 = super.libxml2.override { pythonSupport = false; };
|
||
|
||
# Use Bash from this stage to avoid propagating Bash from a previous stage to the final stdenv.
|
||
ncurses = super.ncurses.override {
|
||
stdenv = self.darwin.bootstrapStdenv.override { shell = lib.getExe self.bash; };
|
||
};
|
||
|
||
darwin = super.darwin.overrideScope (
|
||
selfDarwin: superDarwin:
|
||
darwinPackages prevStage
|
||
// {
|
||
inherit (prevStage.darwin) binutils-unwrapped;
|
||
# Rewrap binutils so it uses the rebuilt Libsystem.
|
||
binutils = superDarwin.binutils.override {
|
||
inherit (prevStage) expand-response-params;
|
||
libc = selfDarwin.libSystem;
|
||
};
|
||
}
|
||
);
|
||
|
||
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;
|
||
}
|
||
];
|
||
|
||
extraNativeBuildInputs = lib.optionals localSystem.isAarch64 [
|
||
prevStage.updateAutotoolsGnuConfigScriptsHook
|
||
prevStage.gnu-config
|
||
];
|
||
|
||
extraPreHook = ''
|
||
stripDebugFlags="-S" # llvm-strip does not support "-p" for Mach-O
|
||
'';
|
||
}
|
||
)
|
||
|
||
# Rebuild LLVM with LLVM. This stage also rebuilds certain dependencies needed by LLVM.
|
||
# The SDK (but not its other inputs) is also rebuilt this stage to pick up the rebuilt cctools for `libtool`.
|
||
(
|
||
prevStage:
|
||
# previous stage2 stdenv:
|
||
assert allDeps isBuiltByBootstrapFilesCompiler [
|
||
(stage1Packages prevStage)
|
||
(bintoolsPackages prevStage)
|
||
(darwinPackages prevStage)
|
||
(llvmToolsPackages prevStage)
|
||
(llvmToolsDeps prevStage)
|
||
];
|
||
|
||
assert allDeps isBuiltByNixpkgsCompiler [
|
||
(llvmLibrariesDeps prevStage)
|
||
(llvmLibrariesPackages prevStage)
|
||
(sdkPackages prevStage)
|
||
(sdkDarwinPackages prevStage)
|
||
];
|
||
|
||
assert allDeps isFromNixpkgs [
|
||
(darwinPackagesNoCC prevStage)
|
||
(sdkPackagesNoCC prevStage)
|
||
];
|
||
|
||
stageFun prevStage {
|
||
name = "bootstrap-stage3";
|
||
|
||
overrides =
|
||
self: super:
|
||
mergeDisjointAttrs [
|
||
(stage1Packages prevStage)
|
||
(disallowedPackages prevStage)
|
||
(llvmLibrariesDeps prevStage)
|
||
(sdkPackages prevStage)
|
||
{
|
||
inherit (prevStage) ccWrapperStdenv;
|
||
|
||
# Disable tests because they use dejagnu, which fails to run.
|
||
libffi = super.libffi.override { doCheck = false; };
|
||
|
||
xar = super.xarMinimal;
|
||
|
||
darwin = super.darwin.overrideScope (
|
||
selfDarwin: superDarwin:
|
||
darwinPackages prevStage
|
||
// sdkDarwinPackages prevStage
|
||
# Rebuild darwin.binutils with the new LLVM, so only inherit libSystem from the previous stage.
|
||
// {
|
||
inherit (prevStage.darwin) libSystem;
|
||
}
|
||
);
|
||
|
||
llvmPackages =
|
||
let
|
||
tools = super.llvmPackages.tools.extend (
|
||
_: superTools: {
|
||
# darwin.binutils-unwrapped needs to build the LLVM man pages, which requires a lot of Python stuff
|
||
# that ultimately ends up depending on git. Fortunately, the git dependency is only for check
|
||
# inputs. The following set of overrides allow the LLVM documentation to be built without
|
||
# pulling curl (and other packages like ffmpeg) into the stdenv bootstrap.
|
||
#
|
||
# However, even without darwin.binutils-unwrapped, this has to be overriden in the LLVM package set
|
||
# because otherwise llvmPackages.llvm-manpages on its own is broken.
|
||
llvm-manpages = superTools.llvm-manpages.override {
|
||
python3Packages = self.python3.pkgs.overrideScope (
|
||
_: superPython: {
|
||
hatch-vcs = superPython.hatch-vcs.overrideAttrs { doInstallCheck = false; };
|
||
markdown-it-py = superPython.markdown-it-py.overrideAttrs { doInstallCheck = false; };
|
||
mdit-py-plugins = superPython.mdit-py-plugins.overrideAttrs { doInstallCheck = false; };
|
||
myst-parser = superPython.myst-parser.overrideAttrs { doInstallCheck = false; };
|
||
}
|
||
);
|
||
};
|
||
}
|
||
);
|
||
libraries = super.llvmPackages.libraries.extend (_: _: llvmLibrariesPackages prevStage);
|
||
in
|
||
super.llvmPackages // { inherit tools libraries; } // tools // libraries;
|
||
}
|
||
];
|
||
|
||
extraNativeBuildInputs = lib.optionals localSystem.isAarch64 [
|
||
prevStage.updateAutotoolsGnuConfigScriptsHook
|
||
prevStage.gnu-config
|
||
];
|
||
|
||
extraPreHook = ''
|
||
stripDebugFlags="-S" # llvm-strip does not support "-p" for Mach-O
|
||
'';
|
||
}
|
||
)
|
||
|
||
# Construct a standard environment with the new clang. Also use the new compiler to rebuild
|
||
# everything that will be part of the final stdenv and isn’t required by it, CF, or Libsystem.
|
||
(
|
||
prevStage:
|
||
# previous stage3 stdenv:
|
||
assert allDeps isBuiltByBootstrapFilesCompiler [
|
||
(stage1Packages prevStage)
|
||
(darwinPackages prevStage)
|
||
];
|
||
|
||
assert allDeps isBuiltByNixpkgsCompiler [
|
||
(bintoolsPackages prevStage)
|
||
(llvmLibrariesDeps prevStage)
|
||
(llvmLibrariesPackages prevStage)
|
||
(llvmToolsDeps prevStage)
|
||
(llvmToolsPackages prevStage)
|
||
(sdkPackages prevStage)
|
||
(sdkDarwinPackages prevStage)
|
||
];
|
||
|
||
assert allDeps isFromNixpkgs [
|
||
(darwinPackagesNoCC prevStage)
|
||
(sdkPackagesNoCC prevStage)
|
||
];
|
||
|
||
stageFun prevStage {
|
||
name = "bootstrap-stage4";
|
||
|
||
overrides =
|
||
self: super:
|
||
mergeDisjointAttrs [
|
||
(bintoolsPackages prevStage)
|
||
(disallowedPackages prevStage)
|
||
(llvmLibrariesDeps prevStage)
|
||
(llvmToolsDeps prevStage)
|
||
(sdkPackages prevStage)
|
||
(sdkPackagesNoCC prevStage)
|
||
{
|
||
inherit (prevStage) ccWrapperStdenv;
|
||
|
||
# Rebuild locales and sigtool with the new clang.
|
||
darwin = super.darwin.overrideScope (
|
||
_: superDarwin:
|
||
sdkDarwinPackages prevStage
|
||
// {
|
||
inherit (prevStage.darwin) binutils-unwrapped libSystem;
|
||
binutils = superDarwin.binutils.override {
|
||
# Build expand-response-params with last stage like below
|
||
inherit (prevStage) expand-response-params;
|
||
};
|
||
# Avoid rebuilding bmake (and Python) just for locales
|
||
locale = superDarwin.locale.override { inherit (prevStage) bmake; };
|
||
}
|
||
);
|
||
|
||
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;
|
||
}
|
||
];
|
||
|
||
extraNativeBuildInputs = lib.optionals localSystem.isAarch64 [
|
||
prevStage.updateAutotoolsGnuConfigScriptsHook
|
||
prevStage.gnu-config
|
||
];
|
||
|
||
extraPreHook = ''
|
||
stripDebugFlags="-S" # llvm-strip does not support "-p" for Mach-O
|
||
'';
|
||
}
|
||
)
|
||
|
||
# Construct the final stdenv. The version of LLVM provided should match the one defined in
|
||
# `all-packages.nix` for Darwin. Nothing should depend on the bootstrap tools or originate from
|
||
# the bootstrap tools.
|
||
#
|
||
# When updating the Darwin stdenv, make sure that the result has no dependency (`nix-store -qR`)
|
||
# on `bootstrapTools` or the binutils built in stage 1.
|
||
(
|
||
prevStage:
|
||
# previous stage4 stdenv:
|
||
|
||
assert allDeps isBuiltByNixpkgsCompiler [
|
||
(lib.filterAttrs (_: pkg: lib.getName pkg != "pkg-config-wrapper") (stage1Packages prevStage)) # pkg-config is a wrapper
|
||
(bintoolsPackages prevStage)
|
||
(darwinPackages prevStage)
|
||
(llvmLibrariesDeps prevStage)
|
||
(llvmLibrariesPackages prevStage)
|
||
(llvmToolsDeps prevStage)
|
||
(llvmToolsPackages prevStage)
|
||
(sdkPackages prevStage)
|
||
(sdkDarwinPackages prevStage)
|
||
{ inherit (prevStage.pkg-config) pkg-config; }
|
||
];
|
||
|
||
assert allDeps isFromNixpkgs [
|
||
(darwinPackagesNoCC prevStage)
|
||
(sdkPackagesNoCC prevStage)
|
||
];
|
||
|
||
let
|
||
cc = prevStage.llvmPackages.clang;
|
||
in
|
||
{
|
||
inherit config overlays;
|
||
stdenv = import ../generic {
|
||
name = "stdenv-darwin";
|
||
|
||
buildPlatform = localSystem;
|
||
hostPlatform = localSystem;
|
||
targetPlatform = localSystem;
|
||
|
||
inherit config;
|
||
|
||
preHook = ''
|
||
${commonPreHook}
|
||
stripDebugFlags="-S" # llvm-strip does not support "-p" for Mach-O
|
||
export PATH_LOCALE=${prevStage.darwin.locale}/share/locale
|
||
'';
|
||
|
||
initialPath = ((import ../generic/common-path.nix) { pkgs = prevStage; });
|
||
|
||
extraNativeBuildInputs = lib.optionals localSystem.isAarch64 [
|
||
prevStage.updateAutotoolsGnuConfigScriptsHook
|
||
];
|
||
|
||
extraBuildInputs = [ prevStage.apple-sdk ];
|
||
|
||
inherit cc;
|
||
|
||
shell = cc.shell;
|
||
|
||
inherit (prevStage.stdenv) fetchurlBoot;
|
||
|
||
extraAttrs = {
|
||
inherit bootstrapTools;
|
||
libc = prevStage.darwin.libSystem;
|
||
shellPackage = prevStage.bash;
|
||
};
|
||
|
||
disallowedRequisites = [ bootstrapTools.out ];
|
||
|
||
allowedRequisites =
|
||
(
|
||
with prevStage;
|
||
[
|
||
apple-sdk
|
||
bash
|
||
bzip2.bin
|
||
bzip2.out
|
||
cc.expand-response-params
|
||
cctools
|
||
cctools.libtool
|
||
coreutils
|
||
darwin.binutils
|
||
darwin.binutils.bintools
|
||
diffutils
|
||
ed
|
||
file
|
||
findutils
|
||
gawk
|
||
gettext
|
||
gmp.out
|
||
gnugrep
|
||
gnugrep.pcre2.out
|
||
gnumake
|
||
gnused
|
||
gnutar
|
||
gzip
|
||
ld64.lib
|
||
ld64.out
|
||
libffi.out
|
||
libtapi.out
|
||
libunistring.out
|
||
libxml2.out
|
||
ncurses.dev
|
||
ncurses.man
|
||
ncurses.out
|
||
openbsm
|
||
openpam
|
||
openssl.out
|
||
patch
|
||
xar.lib
|
||
xcbuild
|
||
xcbuild.xcrun
|
||
xz.bin
|
||
xz.out
|
||
zlib.dev
|
||
zlib.out
|
||
]
|
||
++ apple-sdk.propagatedBuildInputs
|
||
)
|
||
++ lib.optionals localSystem.isAarch64 [
|
||
prevStage.updateAutotoolsGnuConfigScriptsHook
|
||
prevStage.gnu-config
|
||
]
|
||
++ lib.optionals localSystem.isx86_64 [ prevStage.darwin.Csu ]
|
||
++ (with prevStage.darwin; [
|
||
libiconv.out
|
||
libresolv.out
|
||
libsbuf.out
|
||
libSystem
|
||
locale
|
||
])
|
||
++ (with prevStage.llvmPackages; [
|
||
bintools-unwrapped
|
||
clang-unwrapped
|
||
(lib.getLib clang-unwrapped)
|
||
compiler-rt
|
||
compiler-rt.dev
|
||
libcxx
|
||
libcxx.dev
|
||
lld
|
||
llvm
|
||
llvm.lib
|
||
]);
|
||
|
||
__stdenvImpureHostDeps = commonImpureHostDeps;
|
||
__extraImpureHostDeps = commonImpureHostDeps;
|
||
|
||
overrides =
|
||
self: super:
|
||
mergeDisjointAttrs [
|
||
(llvmLibrariesDeps prevStage)
|
||
(llvmToolsDeps prevStage)
|
||
(sdkPackages prevStage)
|
||
(sdkPackagesNoCC prevStage)
|
||
{
|
||
inherit (prevStage)
|
||
diffutils
|
||
ed
|
||
file
|
||
findutils
|
||
gawk
|
||
gettext
|
||
gnumake
|
||
gnused
|
||
gnutar
|
||
gzip
|
||
patch
|
||
;
|
||
|
||
# TODO: Simplify when dropping support for macOS < 11.
|
||
"apple-sdk_${builtins.replaceStrings [ "." ] [ "_" ] sdkMajorVersion}" = self.apple-sdk;
|
||
|
||
darwin = super.darwin.overrideScope (
|
||
_: _:
|
||
sdkDarwinPackages prevStage
|
||
// {
|
||
inherit (prevStage.darwin) libSystem locale sigtool;
|
||
}
|
||
// lib.optionalAttrs (super.stdenv.targetPlatform == localSystem) {
|
||
inherit (prevStage.darwin) binutils binutils-unwrapped;
|
||
}
|
||
);
|
||
}
|
||
(lib.optionalAttrs (super.stdenv.targetPlatform == localSystem) (
|
||
(bintoolsPackages prevStage)
|
||
// {
|
||
inherit (prevStage.llvmPackages) clang;
|
||
# Need to get rid of these when cross-compiling.
|
||
"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 // { inherit (prevStage.llvmPackages) clang; }
|
||
);
|
||
libraries = super."llvmPackages_${llvmVersion}".libraries.extend (
|
||
_: _: llvmLibrariesPackages prevStage
|
||
);
|
||
in
|
||
super."llvmPackages_${llvmVersion}" // { inherit tools libraries; } // tools // libraries;
|
||
}
|
||
))
|
||
];
|
||
};
|
||
}
|
||
)
|
||
|
||
# This "no-op" stage is just a place to put the assertions about the final stage.
|
||
(
|
||
prevStage:
|
||
# previous final stage stdenv:
|
||
assert isBuiltByNixpkgsCompiler prevStage.cctools;
|
||
assert isBuiltByNixpkgsCompiler prevStage.ld64;
|
||
assert isBuiltByNixpkgsCompiler prevStage.darwin.sigtool;
|
||
|
||
assert isFromNixpkgs prevStage.darwin.libSystem;
|
||
assert isFromNixpkgs prevStage.darwin.binutils-unwrapped;
|
||
|
||
assert isBuiltByNixpkgsCompiler prevStage.llvmPackages.clang-unwrapped;
|
||
assert isBuiltByNixpkgsCompiler prevStage.llvmPackages.libllvm;
|
||
assert isBuiltByNixpkgsCompiler prevStage.llvmPackages.libcxx;
|
||
assert isBuiltByNixpkgsCompiler prevStage.llvmPackages.compiler-rt;
|
||
|
||
# Make sure these evaluate since they were disabled explicitly in the bootstrap.
|
||
assert isBuiltByNixpkgsCompiler prevStage.binutils-unwrapped;
|
||
assert isFromNixpkgs prevStage.binutils-unwrapped.src;
|
||
assert isBuiltByNixpkgsCompiler prevStage.curl;
|
||
|
||
# libiconv should be an alias for darwin.libiconv
|
||
assert prevStage.libiconv == prevStage.darwin.libiconv;
|
||
|
||
{
|
||
inherit (prevStage) config overlays stdenv;
|
||
}
|
||
)
|
||
]
|