* Use GCC 4.3 by default.

* Updated stdenv-linux:

  - The bootstrap tools are no longer statically linked (except for
    binaries in the Nixpkgs tree used to download and unpack the
    bootstrap tools).

  - x86_64 uses the same static binaries as i686.  This makes the
    Nixpkgs tree a bit smaller.

  - Use the Linux 2.6.28 headers.

svn path=/nixpkgs/branches/stdenv-updates/; revision=13946

pkgs/stdenv/linux/bootstrap/i686/default.nix

@@ -1,27 +1,13 @@
 {
-  bash = ./bash;
+  sh = ./sh;
   bzip2 = ./bzip2;
-  cp = ./cp;
+  mkdir = ./mkdir;
+  cpio = ./cpio;
+  ln = ./ln;
   curl = ./curl.bz2;
-  tar = ./tar.bz2;
 
-  binutilsURL = {
+  bootstrapTools = {
-    url = http://nixos.org/tarballs/stdenv-linux/i686/r9803/binutils.tar.bz2;
+    url = http://nixos.org/tarballs/stdenv-linux/i686/r13932/bootstrap-tools.cpio.bz2;
-    sha1 = "73532561c2f98d0df641fbd778bc92cea298762a";
+    sha256 = "12z35wnpcbjwczsr9fldp6bjpz7wh5qwylw6xfrr9l4s7gmk3m8a";
-  };
-
-  gccURL = {
-    url = http://nixos.org/tarballs/stdenv-linux/i686/r9803/gcc.tar.bz2;
-    sha1 = "522dc2e22dc42f640b0290638382d45bd43a7d55";
-  };
-
-  glibcURL = {
-    url = http://nixos.org/tarballs/stdenv-linux/i686/r9803/glibc.tar.bz2;
-    sha1 = "b9ae1e43e9977476ef53f8c1c9cd1cff5526ff40";
-  };
-
-  staticToolsURL = {
-    url = http://nixos.org/tarballs/stdenv-linux/i686/r9803/static-tools.tar.bz2;
-    sha1 = "ebe826e848736a82bcdd9a195dd510b533ecc997";
   };
 }

pkgs/stdenv/linux/bootstrap/x86_64/default.nix

@@ -1,27 +1,10 @@
+# Use the static tools for i686-linux.  They work on x86_64-linux
+# machines as well.
+(import ../i686) //
+
 {
-  bash = ./bash;
+  bootstrapTools = {
-  bzip2 = ./bzip2;
+    url = http://nixos.org/tarballs/stdenv-linux/x86_64/r13932/bootstrap-tools.cpio.bz2;
-  cp = ./cp;
+    sha256 = "135lx2945cxf43g9n39dxcamw6f6n8qp5iqbh4xma575rf2bx5js";
-  curl = ./curl.bz2;
-  tar = ./tar.bz2;
-
-  binutilsURL = {
-    url = http://nixos.org/tarballs/stdenv-linux/x86_64/r9803/binutils.tar.bz2;
-    sha1 = "9ac95e34c96c19cd0b925af46c97c9979becaaca";
-  };
-
-  gccURL = {
-    url = http://nixos.org/tarballs/stdenv-linux/x86_64/r9803/gcc.tar.bz2;
-    sha1 = "e8cb32425c8f55833ca081bd74668a029bdf1755";
-  };
-
-  glibcURL = {
-    url = http://nixos.org/tarballs/stdenv-linux/x86_64/r9803/glibc.tar.bz2;
-    sha1 = "74b1698a4595ce4b4f43a33b3ceca1e4459e494e";
-  };
-
-  staticToolsURL = {
-    url = http://nixos.org/tarballs/stdenv-linux/x86_64/r9803/static-tools.tar.bz2;
-    sha1 = "4da3af92c9bcd8fc43b31934d8429412e209741b";
   };
 } 

pkgs/stdenv/linux/default.nix

@@ -9,7 +9,7 @@
 
 rec {
 
-  bootstrapTools =
+  bootstrapFiles =
     if system == "i686-linux" then import ./bootstrap/i686
     else if system == "x86_64-linux" then import ./bootstrap/x86_64
     else if system == "powerpc-linux" then import ./bootstrap/powerpc
@@ -19,114 +19,115 @@ rec {
   # The bootstrap process proceeds in several steps.
 
   
-  # 1) Create a standard environment by downloading pre-built
+  # 1) Create a standard environment by downloading pre-built binaries
-  # statically linked binaries of coreutils, gcc, etc.
+  # of coreutils, GCC, etc.
-
-  # To fetch the pre-built binaries, we use a statically linked `curl'
-  # binary which is unpacked here.
-  curl = derivation {
-    inherit system;
-    name = "curl";
-    builder = bootstrapTools.bash;
-    inherit (bootstrapTools) bzip2 cp curl;
-    args = [ ./scripts/unpack-curl.sh ];
-  };
 
   # This function downloads a file.
-  download = {url, sha1, pkgname}: derivation {
+  download = {url, sha256}: derivation {
     name = baseNameOf (toString url);
-    builder = bootstrapTools.bash;
+    builder = bootstrapFiles.sh;
-    inherit system curl url;
+    inherit system url;
+    inherit (bootstrapFiles) bzip2 mkdir curl cpio ln;
     args = [ ./scripts/download.sh ];
-    outputHashAlgo = "sha1";
+    outputHashAlgo = "sha256";
-    outputHash = sha1;
+    outputHash = sha256;
     impureEnvVars = [ "http_proxy" "https_proxy" "ftp_proxy" "all_proxy" "no_proxy" ];
   };
 
-  # This function downloads and unpacks a file.
+  # Download and unpack the bootstrap tools (coreutils, GCC, Glibc, ...).
-  downloadAndUnpack = pkgname: {url, sha1}: derivation {
+  bootstrapTools = derivation {
-    name = pkgname;
+    name = "bootstrap-tools";
-    builder = bootstrapTools.bash;
+    
-    inherit (bootstrapTools) bzip2 tar cp;
+    builder = bootstrapFiles.sh;
-    args = [ ./scripts/unpack.sh ];
+    
-    tarball = download {inherit url sha1 pkgname;};
+    args = [ ./scripts/unpack-bootstrap-tools.sh ];
+    
+    inherit (bootstrapFiles) bzip2 mkdir curl cpio;
+    
+    tarball = download {
+      inherit (bootstrapFiles.bootstrapTools) url sha256;
+    };
+    
     inherit system;
-    allowedReferences = [];
-  };
     
-  # The various statically linked components that make up the standard
+    # Needed by the GCC wrapper.
-  # environment.
+    langC = true;
-  staticTools = downloadAndUnpack "static-tools" bootstrapTools.staticToolsURL;
+    langCC = true;
-  staticBinutils = downloadAndUnpack "static-binutils" bootstrapTools.binutilsURL;
-  staticGCC = (downloadAndUnpack "static-gcc" bootstrapTools.gccURL)
-    // { langC = true; langCC = false; langF77 = false; };
-  staticGlibc = downloadAndUnpack "static-glibc" bootstrapTools.glibcURL;
-
-
-  # A helper function to call gcc-wrapper.
-  wrapGCC =
-    {gcc ? staticGCC, libc, binutils, shell ? ""}:
-    (import ../../build-support/gcc-wrapper) {
-      nativeTools = false;
-      nativeLibc = false;
-      inherit gcc binutils libc shell;
-      stdenv = stdenvInitial;
-    };
-
-
-  # The "fake" standard environment used to build "real" standard
-  # environments.  It consists of just the basic statically linked
-  # tools.
-  stdenvInitial = let {
-    body = derivation {
-      name = "stdenv-linux-initial";
-      builder = bootstrapTools.bash;
-      args = [ ./scripts/builder-stdenv-initial.sh ];
-      stdenvScript = ../generic/setup.sh;
-      inherit system staticTools curl;
-    } // {
-      # !!! too much duplication with stdenv/generic/default.nix
-      mkDerivation = attrs: (derivation ((removeAttrs attrs ["meta"]) // {
-        builder = bootstrapTools.bash;
-        args = ["-e" attrs.builder];
-        stdenv = body;
-        system = body.system;
-      })) // { meta = if attrs ? meta then attrs.meta else {}; };
-      shell = bootstrapTools.bash;
-    };
   };
   
 
   # This function builds the various standard environments used during
   # the bootstrap.
   stdenvBootFun =
-    {gcc, staticGlibc, extraAttrs ? {}, extraPath ? []}:
+    {gcc, extraAttrs ? {}, extraPath ? [], fetchurl}:
 
-    let
+    import ../generic {
-      fetchurlBoot = import ../../build-support/fetchurl {
+      inherit system;
-        stdenv = stdenvInitial;
-        inherit curl;
-      };
-    in import ../generic {
       name = "stdenv-linux-boot";
-      param1 = if staticGlibc then "static" else "dynamic";
+      param1 = bootstrapTools;
-      preHook = ./scripts/prehook.sh;
+      preHook = builtins.toFile "prehook.sh"
-      stdenv = stdenvInitial;
+        ''
-      shell = bootstrapTools.bash;
+          export LD_LIBRARY_PATH=$param1/lib
-      initialPath = [staticTools] ++ extraPath;
+          export NIX_ENFORCE_PURITY=1
-      inherit fetchurlBoot;
+          havePatchELF=1
+          # Don't patch #!/interpreter because it leads to retained
+          # dependencies on the bootstrapTools in the final stdenv.
+          dontPatchShebangs=1
+        '';
+      shell = "${bootstrapTools}/bin/sh";
+      initialPath = [bootstrapTools] ++ extraPath;
+      fetchurlBoot = fetchurl;
       forceFetchurlBoot = true;
       inherit gcc extraAttrs;
     };
 
 
+  # Build a dummy stdenv with no GCC or working fetchurl.  This is
+  # because we need a stdenv to build the GCC wrapper and fetchurl.
+  stdenvLinuxBoot0 = stdenvBootFun {
+    gcc = "/no-such-path";
+    fetchurl = null;
+  };
+
+  
+  fetchurl = import ../../build-support/fetchurl {
+    stdenv = stdenvLinuxBoot0;
+    curl = bootstrapTools;
+  };
+
+
+  # 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";
+    buildCommand = ''
+      ensureDir $out
+      ln -s ${bootstrapTools}/lib $out/lib
+      ln -s ${bootstrapTools}/include-glibc $out/include
+    '';
+  };
+
+
+  # A helper function to call gcc-wrapper.
+  wrapGCC =
+    {gcc ? bootstrapTools, libc, binutils, shell ? "", name ? "bootstrap-gcc"}:
+    
+    import ../../build-support/gcc-wrapper {
+      nativeTools = false;
+      nativeLibc = false;
+      inherit gcc binutils libc shell name;
+      stdenv = stdenvLinuxBoot0;
+    };
+
+
   # Create the first "real" standard environment.  This one consists
-  # of statically linked components only, and a minimal glibc to keep
+  # of bootstrap tools only, and a minimal Glibc to keep the GCC
-  # the gcc configure script happy.
+  # configure script happy.
   stdenvLinuxBoot1 = stdenvBootFun {
-    # Use the statically linked, downloaded glibc/gcc/binutils.
+    gcc = wrapGCC {libc = bootstrapGlibc; binutils = bootstrapTools;};
-    gcc = wrapGCC {libc = staticGlibc; binutils = staticBinutils;};
+    inherit fetchurl;
-    staticGlibc = true;
   };
   
 
@@ -138,18 +139,18 @@ rec {
   };
 
   
-  # 3) Build Glibc with the statically linked tools.  The result is the
+  # 3) Build Glibc with the bootstrap tools.  The result is the full,
-  #    full, dynamically linked, final Glibc.
+  #    dynamically linked, final Glibc.
   stdenvLinuxGlibc = stdenvLinuxBoot1Pkgs.glibc;
 
   
   # 4) Construct a second stdenv identical to the first, except that
   #    this one uses the Glibc built in step 3.  It still uses
-  #    statically linked tools.
+  #    the rest of the bootstrap tools, including GCC.
   stdenvLinuxBoot2 = removeAttrs (stdenvBootFun {
-    staticGlibc = false;
+    gcc = wrapGCC {binutils = bootstrapTools; libc = stdenvLinuxGlibc;};
-    gcc = wrapGCC {binutils = staticBinutils; libc = stdenvLinuxGlibc;};
     extraAttrs = {glibc = stdenvLinuxGlibc;};
+    inherit fetchurl;
   }) ["gcc" "binutils"];
 
   
@@ -160,25 +161,18 @@ rec {
   };
 
 
-  # Ugh, some packages in stdenvLinuxBoot3Pkgs need "sh", so create a
-  # package that contains just a symlink to bash.
-  shSymlink = stdenvLinuxBoot2Pkgs.runCommand "sh-symlink" {} ''
-    ensureDir $out/bin
-    ln -s $shell $out/bin/sh
-  '';
-
-  
   # 6) Construct a third stdenv identical to the second, except that
   #    this one uses the dynamically linked GCC and Binutils from step
-  #    5.  The other tools (e.g. coreutils) are still static.
+  #    5.  The other tools (e.g. coreutils) are still from the
+  #    bootstrap tools.
   stdenvLinuxBoot3 = stdenvBootFun {
-    staticGlibc = false;
+    gcc = wrapGCC rec {
-    gcc = wrapGCC {
       inherit (stdenvLinuxBoot2Pkgs) binutils;
       libc = stdenvLinuxGlibc;
       gcc = stdenvLinuxBoot2Pkgs.gcc.gcc;
+      name = gcc.name;
     };
-    extraPath = [stdenvLinuxBoot2Pkgs.replace shSymlink];
+    inherit fetchurl;
   };
 
   
@@ -192,21 +186,31 @@ rec {
   # 8) Construct the final stdenv.  It uses the Glibc, GCC and
   #    Binutils built above, and adds in dynamically linked versions
   #    of all other tools.
+  #
+  #    When updating stdenvLinux, make sure that the result has no
+  #    dependency (`nix-store -qR') on bootstrapTools.
   stdenvLinux = import ../generic {
     name = "stdenv-linux";
-    preHook = ./scripts/prehook.sh;
+    
+    inherit system;
+    
+    preHook = builtins.toFile "prehook.sh"
+      ''
+        export NIX_ENFORCE_PURITY=1
+        havePatchELF=1
+      '';
+    
     initialPath = [
       ((import ../common-path.nix) {pkgs = stdenvLinuxBoot3Pkgs;})
       stdenvLinuxBoot3Pkgs.patchelf
     ];
 
-    stdenv = stdenvInitial;
+    gcc = wrapGCC rec {
-
-    gcc = wrapGCC {
       inherit (stdenvLinuxBoot2Pkgs) binutils;
       libc = stdenvLinuxGlibc;
       gcc = stdenvLinuxBoot2Pkgs.gcc.gcc;
       shell = stdenvLinuxBoot3Pkgs.bash + "/bin/sh";
+      name = gcc.name;
     };
 
     shell = stdenvLinuxBoot3Pkgs.bash + "/bin/sh";

pkgs/stdenv/linux/scripts/builder-stdenv-initial.sh

@@ -1,7 +0,0 @@
-set -e
-
-PATH=$staticTools/bin
-
-mkdir $out
-
-sed -e "s^@initialPath@^$staticTools^" -e "s^@preHook@^^" -e "s^@postHook@^^" -e "s^@shell@^$SHELL^" < $stdenvScript > $out/setup

pkgs/stdenv/linux/scripts/download.sh

@@ -1,3 +1,8 @@
 set -e
+
+$ln -s $curl curl.bz2
+$bzip2 -d -f curl.bz2
+./curl --version
+
 echo "downloading $out from $url"
-$curl/bin/curl --fail --location --max-redirs 20 "$url" > "$out"
+./curl --fail --location --max-redirs 20 "$url" > "$out"

pkgs/stdenv/linux/scripts/prehook.sh

@@ -1,8 +1,3 @@
 export NIX_ENFORCE_PURITY=1
 
-if test "$param1" = "static"; then
-    export NIX_CFLAGS_LINK="-static"
-    export NIX_LDFLAGS_BEFORE="-static"
-fi
-
 havePatchELF=1

pkgs/stdenv/linux/scripts/unpack-bootstrap-tools.sh

@@ -0,0 +1,35 @@
+set -e
+
+# Unpack the bootstrap tools tarball.
+echo Unpacking the bootstrap tools...
+$mkdir $out
+$bzip2 -d < $tarball | (cd $out && $cpio -V -i)
+
+# Set the ELF interpreter / RPATH in the bootstrap binaries.
+echo Patching the bootstrap tools...
+
+# On x86_64, ld-linux-x86-64.so.2 barfs on patchelf'ed programs.  So
+# use a copy of patchelf.
+LD_LIBRARY_PATH=$out/lib $out/lib/ld-linux*.so.2 $out/bin/cp $out/bin/patchelf .
+
+for i in $out/bin/* $out/libexec/gcc/*/*/*; do
+    echo patching $i
+    if ! test -L $i; then
+         LD_LIBRARY_PATH=$out/lib $out/lib/ld-linux*.so.2 \
+             ./patchelf --set-interpreter $out/lib/ld-linux*.so.2 --set-rpath $out/lib $i
+    fi
+done
+
+# Fix the libc linker script.
+export PATH=$out/bin
+cat $out/lib/libc.so | sed "s|/nix/store/e*-[^/]*/|$out/|g" > $out/lib/libc.so.tmp
+mv $out/lib/libc.so.tmp $out/lib/libc.so
+
+# Provide some additional symlinks.
+ln -s bash $out/bin/sh
+
+ln -s bzip2 $out/bin/bunzip2
+
+# fetchurl needs curl.
+bzip2 -d < $curl > $out/bin/curl
+chmod +x $out/bin/curl

pkgs/stdenv/linux/scripts/unpack-curl.sh

@@ -1,11 +0,0 @@
-set -x
-set -e
-
-# Tricky: need to make $out/bin without mkdir ;-).  So use cp to copy
-# the current (empty) directory.
-$cp -prvd . $out
-$cp -prvd . $out/bin
-
-$cp $curl curl.bz2
-$bzip2 -d curl.bz2
-$cp curl $out/bin

pkgs/stdenv/linux/scripts/unpack.sh

@@ -1,8 +0,0 @@
-set -e
-
-$cp $tar .tar.bz2
-$bzip2 -d .tar.bz2
-
-$bzip2 -d < $tarball | ./.tar xvf -
-
-$cp -prd * $out

pkgs/top-level/all-packages.nix

@@ -1514,7 +1514,7 @@ let
     inherit stdenv;
   };
 
-  gcc = gcc42;
+  gcc = gcc43;
 
   gcc295 = wrapGCC (import ../development/compilers/gcc-2.95 {
     inherit fetchurl stdenv noSysDirs;
@@ -1545,16 +1545,16 @@ let
     profiledCompiler = false;
   });
 
-  gcc42 = useFromStdenv "gcc" (wrapGCC (import ../development/compilers/gcc-4.2 {
+  gcc42 = wrapGCC (import ../development/compilers/gcc-4.2 {
     inherit fetchurl stdenv noSysDirs;
-    profiledCompiler = true;
-  }));
-
-  gcc43 = wrapGCC (import ../development/compilers/gcc-4.3 {
-    inherit fetchurl stdenv texinfo gmp mpfr noSysDirs;
     profiledCompiler = false;
   });
 
+  gcc43 = useFromStdenv "gcc" (wrapGCC (import ../development/compilers/gcc-4.3 {
+    inherit fetchurl stdenv texinfo gmp mpfr noSysDirs;
+    profiledCompiler = true;
+  }));
+
   gcc43multi = lowPrio (wrapGCCWith (import ../build-support/gcc-wrapper) glibc_multi (import ../development/compilers/gcc-4.3 {
     stdenv = overrideGCC stdenv (wrapGCCWith (import ../build-support/gcc-wrapper) glibc_multi gcc42);
     inherit fetchurl texinfo gmp mpfr noSysDirs;
@@ -2993,6 +2993,7 @@ let
 
   gmp = import ../development/libraries/gmp {
     inherit fetchurl stdenv m4;
+    cxx = false;
   };
 
   goocanvas = import ../development/libraries/goocanvas {
@@ -6081,7 +6082,7 @@ let
     inherit fetchurl stdenv bison flex;
   };
 
-  kernelHeaders = kernelHeaders_2_6_23;
+  kernelHeaders = kernelHeaders_2_6_28;
 
   kernelHeaders_2_6_18 = import ../os-specific/linux/kernel-headers/2.6.18.5.nix {
     inherit fetchurl stdenv unifdef;