public/nixpkgs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'nilcons-contrib-stdenv_stages_refactor' into staging

Browse Source
This commit is contained in:
Eelco Dolstra 2014-08-24 18:03:00 +02:00
commit 0f7cb13f38
1 changed files with 115 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
pkgs/stdenv/linux/default.nix
View File

@ -35,8 +35,8 @@ rec {
# The bootstrap process proceeds in several steps. # The bootstrap process proceeds in several steps.
# 1) Create a standard environment by downloading pre-built binaries # Create a standard environment by downloading pre-built binaries of
# of coreutils, GCC, etc. # coreutils, GCC, etc.
# Download and unpack the bootstrap tools (coreutils, GCC, Glibc, ...). # Download and unpack the bootstrap tools (coreutils, GCC, Glibc, ...).
@ -66,12 +66,26 @@ rec {
}; };
# This function builds the various standard environments used during # A helper function to call gcc-wrapper.
# the bootstrap. wrapGCC =
stdenvBootFun = { gcc, libc, binutils, coreutils, name }:
{gcc, extraAttrs ? {}, overrides ? (pkgs: {}), extraPath ? [], fetchurl}:
import ../generic { lib.makeOverridable (import ../../build-support/gcc-wrapper) {
nativeTools = false;
nativeLibc = false;
inherit gcc binutils coreutils libc name;
stdenv = stage0.stdenv;
};
# This function builds the various standard environments used during
# the bootstrap. In all stages, we build an stdenv and the package
# set that can be built with that stdenv.
stageFun =
{gcc, extraAttrs ? {}, overrides ? (pkgs: {}), extraPath ? []}:
let
thisStdenv = import ../generic {
inherit system config; inherit system config;
name = "stdenv-linux-boot"; name = "stdenv-linux-boot";
preHook = preHook =
@ -83,35 +97,35 @@ rec {
''; '';
shell = "${bootstrapTools}/bin/sh"; shell = "${bootstrapTools}/bin/sh";
initialPath = [bootstrapTools] ++ extraPath; initialPath = [bootstrapTools] ++ extraPath;
fetchurlBoot = fetchurl; fetchurlBoot = import ../../build-support/fetchurl {
stdenv = stage0.stdenv;
curl = bootstrapTools;
};
inherit gcc; inherit gcc;
# Having the proper 'platform' in all the stdenvs allows getting proper # Having the proper 'platform' in all the stdenvs allows getting proper
# linuxHeaders for example. # linuxHeaders for example.
extraAttrs = extraAttrs // { inherit platform; }; extraAttrs = extraAttrs // { inherit platform; };
overrides = pkgs: (overrides pkgs) // { overrides = pkgs: (overrides pkgs) // { fetchurl = thisStdenv.fetchurlBoot; };
inherit fetchurl;
}; };
thisPkgs = allPackages {
inherit system platform;
bootStdenv = thisStdenv;
}; };
in { stdenv = thisStdenv; pkgs = thisPkgs; };
# Build a dummy stdenv with no GCC or working fetchurl. This is # Build a dummy stdenv with no GCC or working fetchurl. This is
# because we need a stdenv to build the GCC wrapper and fetchurl. # because we need a stdenv to build the GCC wrapper and fetchurl.
stdenvLinuxBoot0 = stdenvBootFun { stage0 = stageFun {
gcc = "/no-such-path"; gcc = "/no-such-path";
fetchurl = null;
};
overrides = pkgs: {
fetchurl = import ../../build-support/fetchurl { # The Glibc include directory cannot have the same prefix as the
stdenv = stdenvLinuxBoot0; # GCC include directory, since GCC gets confused otherwise (it
curl = bootstrapTools; # will search the Glibc headers before the GCC headers). So
}; # create a dummy Glibc here, which will be used in the stdenv of
# stage1.
glibc = stage0.stdenv.mkDerivation {
# The Glibc include directory cannot have the same prefix as the GCC
# include directory, since GCC gets confused otherwise (it will
# search the Glibc headers before the GCC headers). So create a
# dummy Glibc.
bootstrapGlibc = stdenvLinuxBoot0.mkDerivation {
name = "bootstrap-glibc"; name = "bootstrap-glibc";
buildCommand = '' buildCommand = ''
mkdir -p $out mkdir -p $out
@ -119,84 +133,66 @@ rec {
ln -s ${bootstrapTools}/include-glibc $out/include ln -s ${bootstrapTools}/include-glibc $out/include
''; '';
}; };
};
# A helper function to call gcc-wrapper.
wrapGCC =
{ gcc ? bootstrapTools, libc, binutils, coreutils, shell ? "", name ? "bootstrap-gcc-wrapper" }:
lib.makeOverridable (import ../../build-support/gcc-wrapper) {
nativeTools = false;
nativeLibc = false;
inherit gcc binutils coreutils libc shell name;
stdenv = stdenvLinuxBoot0;
}; };
# Create the first "real" standard environment. This one consists # Create the first "real" standard environment. This one consists
# of bootstrap tools only, and a minimal Glibc to keep the GCC # of bootstrap tools only, and a minimal Glibc to keep the GCC
# configure script happy. # configure script happy.
stdenvLinuxBoot1 = stdenvBootFun { #
# For clarity, we only use the previous stage when specifying these
# stages. So stageN should only ever have references for stage{N-1}.
#
# If we ever need to use a package from more than one stage back, we
# simply re-export those packages in the middle stage(s) using the
# overrides attribute and the inherit syntax.
stage1 = stageFun {
gcc = wrapGCC { gcc = wrapGCC {
libc = bootstrapGlibc; gcc = bootstrapTools;
libc = stage0.pkgs.glibc;
binutils = bootstrapTools; binutils = bootstrapTools;
coreutils = bootstrapTools; coreutils = bootstrapTools;
name = "bootstrap-gcc-wrapper";
};
# Rebuild binutils to use from stage2 onwards.
overrides = pkgs: {
binutils = pkgs.binutils.override { gold = false; };
inherit (stage0.pkgs) glibc;
}; };
inherit fetchurl;
}; };
# 2) These are the packages that we can build with the first # 2nd stdenv that contains our own rebuilt binutils and is used for
# stdenv. We only need binutils, because recent Glibcs # compiling our own Glibc.
# require recent Binutils, and those in bootstrap-tools may stage2 = stageFun {
# be too old.
stdenvLinuxBoot1Pkgs = allPackages {
inherit system platform;
bootStdenv = stdenvLinuxBoot1;
};
binutils1 = stdenvLinuxBoot1Pkgs.binutils.override { gold = false; };
# 3) 2nd stdenv that we will use to build only Glibc.
stdenvLinuxBoot2 = stdenvBootFun {
gcc = wrapGCC { gcc = wrapGCC {
libc = bootstrapGlibc; gcc = bootstrapTools;
binutils = binutils1; libc = stage1.pkgs.glibc;
binutils = stage1.pkgs.binutils;
coreutils = bootstrapTools; coreutils = bootstrapTools;
name = "bootstrap-gcc-wrapper";
}; };
overrides = pkgs: { overrides = pkgs: {
inherit (stdenvLinuxBoot1Pkgs) perl; inherit (stage1.pkgs) perl binutils paxctl;
# This also contains the full, dynamically linked, final Glibc.
}; };
inherit fetchurl;
}; };
# 4) These are the packages that we can build with the 2nd # Construct a third stdenv identical to the 2nd, except that this
# stdenv. # one uses the rebuilt Glibc from stage2. It still uses the recent
stdenvLinuxBoot2Pkgs = allPackages {
inherit system platform;
bootStdenv = stdenvLinuxBoot2;
};
# 5) Build Glibc with the bootstrap tools. The result is the full,
# dynamically linked, final Glibc.
stdenvLinuxGlibc = stdenvLinuxBoot2Pkgs.glibc;
# 6) Construct a third stdenv identical to the 2nd, except that this
# one uses the Glibc built in step 5. It still uses the recent
# binutils and rest of the bootstrap tools, including GCC. # binutils and rest of the bootstrap tools, including GCC.
stdenvLinuxBoot3 = stdenvBootFun { stage3 = stageFun {
gcc = wrapGCC { gcc = wrapGCC {
binutils = binutils1; gcc = bootstrapTools;
libc = stage2.pkgs.glibc;
binutils = stage2.pkgs.binutils;
coreutils = bootstrapTools; coreutils = bootstrapTools;
libc = stdenvLinuxGlibc; name = "bootstrap-gcc-wrapper";
}; };
overrides = pkgs: { overrides = pkgs: {
glibc = stdenvLinuxGlibc; inherit (stage2.pkgs) binutils glibc perl;
inherit (stdenvLinuxBoot1Pkgs) perl;
# Link GCC statically against GMP etc. This makes sense because # Link GCC statically against GMP etc. This makes sense because
# these builds of the libraries are only used by GCC, so it # these builds of the libraries are only used by GCC, so it
# reduces the size of the stdenv closure. # reduces the size of the stdenv closure.
@ -208,54 +204,36 @@ rec {
ppl = pkgs.ppl.override { stdenv = pkgs.makeStaticLibraries pkgs.stdenv; }; ppl = pkgs.ppl.override { stdenv = pkgs.makeStaticLibraries pkgs.stdenv; };
}; };
extraAttrs = { extraAttrs = {
glibc = stdenvLinuxGlibc; # Required by gcc47 build glibc = stage2.pkgs.glibc; # Required by gcc47 build
}; };
extraPath = [ stdenvLinuxBoot1Pkgs.paxctl ]; extraPath = [ stage2.pkgs.paxctl ];
inherit fetchurl;
}; };
# 7) The packages that can be built using the third stdenv. # Construct a fourth stdenv that uses the new GCC. But coreutils is
stdenvLinuxBoot3Pkgs = allPackages { # still from the bootstrap tools.
inherit system platform; stage4 = stageFun {
bootStdenv = stdenvLinuxBoot3; gcc = wrapGCC {
}; gcc = stage3.pkgs.gcc.gcc;
libc = stage3.pkgs.glibc;
binutils = stage3.pkgs.binutils;
# 8) Construct a fourth stdenv identical to the second, except that
# this one uses the new GCC from step 7. The other tools
# (e.g. coreutils) are still from the bootstrap tools.
stdenvLinuxBoot4 = stdenvBootFun {
gcc = wrapGCC rec {
binutils = binutils1;
coreutils = bootstrapTools; coreutils = bootstrapTools;
libc = stdenvLinuxGlibc;
gcc = stdenvLinuxBoot3Pkgs.gcc.gcc;
name = ""; name = "";
}; };
extraPath = [ stdenvLinuxBoot3Pkgs.xz ]; extraPath = [ stage3.pkgs.xz ];
overrides = pkgs: { overrides = pkgs: {
inherit (stdenvLinuxBoot1Pkgs) perl; inherit (stage3.pkgs) gettext gnum4 gmp perl glibc;
inherit (stdenvLinuxBoot3Pkgs) gettext gnum4 gmp;
}; };
inherit fetchurl;
}; };
# 9) The packages that can be built using the fourth stdenv. # Construct the final stdenv. It uses the Glibc and GCC, and adds
stdenvLinuxBoot4Pkgs = allPackages { # in a new binutils that doesn't depend on bootstrap-tools, as well
inherit system platform; # as dynamically linked versions of all other tools.
bootStdenv = stdenvLinuxBoot4;
};
# 10) Construct the final stdenv. It uses the Glibc and GCC, and
# adds in a new binutils that doesn't depend on bootstrap-tools,
# as well as dynamically linked versions of all other tools.
# #
# When updating stdenvLinux, make sure that the result has no # When updating stdenvLinux, make sure that the result has no
# dependency (`nix-store -qR') on bootstrapTools or the # dependency (`nix-store -qR') on bootstrapTools or the first
# first binutils built. # binutils built.
stdenvLinux = import ../generic rec { stdenvLinux = import ../generic rec {
inherit system config; inherit system config;
@ -268,34 +246,31 @@ rec {
''; '';
initialPath = initialPath =
((import ../common-path.nix) {pkgs = stdenvLinuxBoot4Pkgs;}) ((import ../common-path.nix) {pkgs = stage4.pkgs;})
++ [stdenvLinuxBoot4Pkgs.patchelf stdenvLinuxBoot4Pkgs.paxctl ]; ++ [stage4.pkgs.patchelf stage4.pkgs.paxctl ];
gcc = wrapGCC rec { shell = stage4.pkgs.bash + "/bin/bash";
inherit (stdenvLinuxBoot4Pkgs) binutils coreutils;
libc = stdenvLinuxGlibc; gcc = (wrapGCC rec {
gcc = stdenvLinuxBoot4.gcc.gcc; gcc = stage4.stdenv.gcc.gcc;
shell = stdenvLinuxBoot4Pkgs.bash + "/bin/bash"; libc = stage4.pkgs.glibc;
inherit (stage4.pkgs) binutils coreutils;
name = ""; name = "";
}; }).override { inherit shell; };
shell = stdenvLinuxBoot4Pkgs.bash + "/bin/bash"; fetchurlBoot = stage4.stdenv.fetchurl;
fetchurlBoot = fetchurl;
extraAttrs = { extraAttrs = {
inherit (stdenvLinuxBoot3Pkgs) glibc; inherit (stage4.pkgs) glibc;
inherit platform bootstrapTools; inherit platform bootstrapTools;
shellPackage = stdenvLinuxBoot4Pkgs.bash; shellPackage = stage4.pkgs.bash;
}; };
overrides = pkgs: { overrides = pkgs: {
inherit gcc; inherit gcc;
inherit (stdenvLinuxBoot3Pkgs) glibc; inherit (stage4.pkgs)
inherit (stdenvLinuxBoot4Pkgs) binutils; gzip bzip2 xz bash binutils coreutils diffutils findutils gawk
inherit (stdenvLinuxBoot4Pkgs) glibc gnumake gnused gnutar gnugrep gnupatch patchelf
gzip bzip2 xz bash coreutils diffutils findutils gawk
gnumake gnused gnutar gnugrep gnupatch patchelf
attr acl paxctl; attr acl paxctl;
}; };
}; };