treewide: Leverage new top-level `libc` in bootstrap, and simplify

Picking up where #414321 left off, we can now simplify some things by
using `pkgs.libc` or `targetPackages.libc` consistently.

Individual packages should probably continue using `stdenv.cc.libc`, for
now at least, since it is possible they are given a `stdenv.cc` with an
alternative libc, but for the treewide code, the top-level `libc`
package is preferable and easier to work with.

Co-authored-by: Tristan Ross <[e-mail]>

pkgs/servers/x11/xorg/overrides.nix

···
         buildPackages.stdenv.cc
       ]
       ++ lib.optionals stdenv.hostPlatform.isStatic [
-        (xorg.buildPackages.stdenv.cc.libc.static or null)
+        (xorg.buildPackages.libc.static or null)
       ];
     preConfigure = ''
       sed 's,^as_dummy.*,as_dummy="\$PATH",' -i configure

pkgs/stdenv/darwin/default.nix

···
             bintools = prevStage.darwin.binutils;
 
             isClang = true;
-            libc = prevStage.darwin.libSystem;
+            inherit (prevStage) libc;
             inherit (prevStage.llvmPackages) libcxx;
 
             inherit lib;
···
 
     assert allDeps isFromNixpkgs [
       (sdkPackagesNoCC prevStage)
-      { inherit (prevStage.darwin) binutils libSystem; }
+      {
+        inherit (prevStage.darwin) binutils libSystem;
+        inherit (prevStage) libc;
+      }
     ];
 
     stageFun prevStage {
···
     assert isBuiltByNixpkgsCompiler prevStage.darwin.sigtool;
 
     assert isFromNixpkgs prevStage.darwin.libSystem;
+    assert isFromNixpkgs prevStage.libc;
     assert isFromNixpkgs prevStage.darwin.binutils-unwrapped;
 
     assert isBuiltByNixpkgsCompiler prevStage.llvmPackages.clang-unwrapped;

pkgs/stdenv/linux/default.nix

···
     isFromBootstrapFiles = true;
   };
 
-  getLibc = stage: stage.${localSystem.libc};
-
   # 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.
···
               cc = prevStage.gcc-unwrapped;
               bintools = prevStage.binutils;
               isGNU = true;
-              libc = getLibc prevStage;
+              inherit (prevStage) libc;
               inherit lib;
               inherit (prevStage) coreutils gnugrep;
               stdenvNoCC = prevStage.ccWrapperStdenv;
···
                   postFixup =
                     (a.postFixup or "")
                     + ''
-                      echo "--sysroot=${lib.getDev (getLibc prevStage)}" >> $out/nix-support/cc-cflags
+                      echo "--sysroot=${lib.getDev prevStage.libc}" >> $out/nix-support/cc-cflags
                     '';
                 }
               );
···
           nativeTools = false;
           nativeLibc = false;
           expand-response-params = "";
-          libc = getLibc self;
           inherit lib;
-          inherit (self) stdenvNoCC coreutils gnugrep;
+          inherit (self)
+            stdenvNoCC
+            coreutils
+            gnugrep
+            libc
+            ;
           bintools = bootstrapTools;
           runtimeShell = "${bootstrapTools}/bin/bash";
         };
···
     # previous stage0 stdenv:
     assert isFromBootstrapFiles prevStage.binutils.bintools;
     assert isFromBootstrapFiles prevStage."${localSystem.libc}";
+    assert isFromBootstrapFiles prevStage.libc;
     assert isFromBootstrapFiles prevStage.gcc-unwrapped;
     assert isFromBootstrapFiles prevStage.coreutils;
     assert isFromBootstrapFiles prevStage.gnugrep;
···
           binutils
           ;
 
-        ${localSystem.libc} = getLibc prevStage;
+        ${localSystem.libc} = prevStage.${localSystem.libc};
 
         # A threaded perl build needs glibc/libpthread_nonshared.a,
         # which is not included in bootstrapTools, so disable threading.
···
     prevStage:
     assert isBuiltByBootstrapFilesCompiler prevStage.binutils-unwrapped;
     assert isFromBootstrapFiles prevStage."${localSystem.libc}";
+    assert isFromBootstrapFiles prevStage.libc;
     assert isFromBootstrapFiles prevStage.gcc-unwrapped;
     assert isFromBootstrapFiles prevStage.coreutils;
     assert isFromBootstrapFiles prevStage.gnugrep;
···
           perl
           patchelf
           ;
-        ${localSystem.libc} = getLibc prevStage;
+        ${localSystem.libc} = prevStage.${localSystem.libc};
         gmp = super.gmp.override { cxx = false; };
         # This stage also rebuilds binutils which will of course be used only in the next stage.
         # We inherit this until stage3, in stage4 it will be rebuilt using the adjacent bash/runtimeShell pkg.
···
     # previous stage1 stdenv:
     assert isBuiltByBootstrapFilesCompiler prevStage.binutils-unwrapped;
     assert isFromBootstrapFiles prevStage."${localSystem.libc}";
+    assert isFromBootstrapFiles prevStage.libc;
     assert isBuiltByBootstrapFilesCompiler prevStage.gcc-unwrapped;
     assert isFromBootstrapFiles prevStage.coreutils;
     assert isFromBootstrapFiles prevStage.gnugrep;
···
           doCheck = false;
         });
 
+        # Avoids infinite recursion, as this is in the build-time dependencies of libc.
+        libiconv = self.libcIconv prevStage.libc;
+
         # We need libidn2 and its dependency libunistring as glibc dependency.
         # To avoid the cycle, we build against bootstrap libc, nuke references,
         # and use the result as input for our final glibc.  We also pass this pair
···
         binutils = prevStage.binutils.override {
           # Rewrap the binutils with the new glibc, so both the next
           # stage's wrappers use it.
-          libc = getLibc self;
+          inherit (self) libc;
 
           # Unfortunately, when building gcc in the next stage, its LTO plugin
           # would use the final libc but `ld` would use the bootstrap one,
···
               mkdir -p "$out"/bin
               cp -a '${prevStage.bintools.bintools}'/bin/* "$out"/bin/
               chmod +w "$out"/bin/ld.bfd
-              patchelf --set-interpreter '${getLibc self}'/lib/ld*.so.? \
-                --set-rpath "${getLibc self}/lib:$(patchelf --print-rpath "$out"/bin/ld.bfd)" \
+              patchelf --set-interpreter '${self.libc}'/lib/ld*.so.? \
+                --set-rpath "${self.libc}/lib:$(patchelf --print-rpath "$out"/bin/ld.bfd)" \
                 "$out"/bin/ld.bfd
             '';
           };
···
     # previous stage2 stdenv:
     assert isBuiltByNixpkgsCompiler prevStage.binutils-unwrapped;
     assert isBuiltByNixpkgsCompiler prevStage.${localSystem.libc};
+    assert isBuiltByNixpkgsCompiler prevStage.libc;
     assert isBuiltByBootstrapFilesCompiler prevStage.gcc-unwrapped;
     assert isFromBootstrapFiles prevStage.coreutils;
     assert isFromBootstrapFiles prevStage.gnugrep;
···
           gmp = super.gmp.override { cxx = false; };
         }
         // {
-          ${localSystem.libc} = getLibc prevStage;
+          ${localSystem.libc} = prevStage.${localSystem.libc};
           gcc-unwrapped =
             (super.gcc-unwrapped.override (
               commonGccOverrides
···
     # previous stage3 stdenv:
     assert isBuiltByNixpkgsCompiler prevStage.binutils-unwrapped;
     assert isBuiltByNixpkgsCompiler prevStage.${localSystem.libc};
+    assert isBuiltByNixpkgsCompiler prevStage.libc;
     assert isBuiltByNixpkgsCompiler prevStage.gcc-unwrapped;
     assert isFromBootstrapFiles prevStage.coreutils;
     assert isFromBootstrapFiles prevStage.gnugrep;
···
           libidn2
           libunistring
           ;
-        ${localSystem.libc} = getLibc prevStage;
+        ${localSystem.libc} = prevStage.${localSystem.libc};
         # Since this is the first fresh build of binutils since stage2, our own runtimeShell will be used.
         binutils = super.binutils.override {
           # Build expand-response-params with last stage like below
···
           inherit (prevStage) expand-response-params;
           cc = prevStage.gcc-unwrapped;
           bintools = self.binutils;
-          libc = getLibc self;
           inherit lib;
           inherit (self)
             stdenvNoCC
             coreutils
             gnugrep
             runtimeShell
+            libc
             ;
           fortify-headers = self.fortify-headers;
         };
···
     # which applies here as well.
     assert isBuiltByNixpkgsCompiler prevStage.binutils-unwrapped;
     assert isBuiltByNixpkgsCompiler prevStage.${localSystem.libc};
+    assert isBuiltByNixpkgsCompiler prevStage.libc;
     assert isBuiltByNixpkgsCompiler prevStage.gcc-unwrapped;
     assert isBuiltByNixpkgsCompiler prevStage.coreutils;
     assert isBuiltByNixpkgsCompiler prevStage.gnugrep;
···
             libunistring
           ]
           # More complicated cases
-          ++ (map (x: lib.getOutput x (getLibc prevStage)) [
+          ++ (map (x: lib.getOutput x (prevStage.libc)) [
             "out"
             "dev"
             "bin"
···
               libunistring
               ;
             inherit (prevStage.gnugrep) pcre2;
-            ${localSystem.libc} = getLibc prevStage;
+            ${localSystem.libc} = prevStage.${localSystem.libc};
 
             # Hack: avoid libidn2.{bin,dev} referencing bootstrap tools.  There's a logical cycle.
             libidn2 = import ../../development/libraries/libidn2/no-bootstrap-reference.nix {
···
     # which applies here as well.
     assert isBuiltByNixpkgsCompiler prevStage.binutils-unwrapped;
     assert isBuiltByNixpkgsCompiler prevStage.${localSystem.libc};
+    assert isBuiltByNixpkgsCompiler prevStage.libc;
     assert isBuiltByNixpkgsCompiler prevStage.gcc-unwrapped;
     assert isBuiltByNixpkgsCompiler prevStage.coreutils;
     assert isBuiltByNixpkgsCompiler prevStage.gnugrep;

pkgs/stdenv/linux/make-bootstrap-tools.nix

···
 }:
 
 let
-  inherit (pkgs) lib stdenv config;
-
-  libc = pkgs.stdenv.cc.libc;
+  inherit (pkgs)
+    lib
+    stdenv
+    config
+    libc
+    ;
 
   patchelf = pkgs.patchelf.overrideAttrs (previousAttrs: {
     NIX_CFLAGS_COMPILE = (previousAttrs.NIX_CFLAGS_COMPILE or [ ]) ++ [

pkgs/top-level/all-packages.nix

···
   wrapBintoolsWith =
     {
       bintools,
-      libc ? if stdenv.targetPlatform != stdenv.hostPlatform then targetPackages.libc else stdenv.cc.libc,
+      libc ? targetPackages.libc or pkgs.libc,
       ...
     }@extraArgs:
     callPackage ../build-support/bintools-wrapper (
···
 
   # We can choose:
   libc =
-    if stdenv.hostPlatform == stdenv.buildPlatform then
-      # TODO get rid of this branch after the native boostrap is reworked
-      stdenv.cc.libc
+    let
+      inherit (stdenv.hostPlatform) libc;
+      # libc is hackily often used from the previous stage. This `or`
+      # hack fixes the hack, *sigh*.
+    in
+    if libc == null then
+      null
+    else if libc == "glibc" then
+      glibc
+    else if libc == "bionic" then
+      bionic
+    else if libc == "uclibc" then
+      uclibc
+    else if libc == "avrlibc" then
+      avrlibc
+    else if libc == "newlib" && stdenv.hostPlatform.isMsp430 then
+      msp430Newlib
+    else if libc == "newlib" && stdenv.hostPlatform.isVc4 then
+      vc4-newlib
+    else if libc == "newlib" && stdenv.hostPlatform.isOr1k then
+      or1k-newlib
+    else if libc == "newlib" then
+      newlib
+    else if libc == "newlib-nano" then
+      newlib-nano
+    else if libc == "musl" then
+      musl
+    else if libc == "msvcrt" then
+      windows.mingw_w64
+    else if libc == "ucrt" then
+      windows.mingw_w64
+    else if libc == "libSystem" then
+      if stdenv.hostPlatform.useiOSPrebuilt then darwin.iosSdkPkgs.libraries else darwin.libSystem
+    else if libc == "fblibc" then
+      freebsd.libc
+    else if libc == "oblibc" then
+      openbsd.libc
+    else if libc == "nblibc" then
+      netbsd.libc
+    else if libc == "wasilibc" then
+      wasilibc
+    else if libc == "relibc" then
+      relibc
+    else if name == "llvm" then
+      llvmPackages_20.libc
     else
-      let
-        inherit (stdenv.hostPlatform) libc;
-        # libc is hackily often used from the previous stage. This `or`
-        # hack fixes the hack, *sigh*.
-      in
-      if libc == null then
-        null
-      else if libc == "glibc" then
-        glibc
-      else if libc == "bionic" then
-        bionic
-      else if libc == "uclibc" then
-        uclibc
-      else if libc == "avrlibc" then
-        avrlibc
-      else if libc == "newlib" && stdenv.hostPlatform.isMsp430 then
-        msp430Newlib
-      else if libc == "newlib" && stdenv.hostPlatform.isVc4 then
-        vc4-newlib
-      else if libc == "newlib" && stdenv.hostPlatform.isOr1k then
-        or1k-newlib
-      else if libc == "newlib" then
-        newlib
-      else if libc == "newlib-nano" then
-        newlib-nano
-      else if libc == "musl" then
-        musl
-      else if libc == "msvcrt" then
-        windows.mingw_w64
-      else if libc == "ucrt" then
-        windows.mingw_w64
-      else if libc == "libSystem" then
-        if stdenv.hostPlatform.useiOSPrebuilt then darwin.iosSdkPkgs.libraries else darwin.libSystem
-      else if libc == "fblibc" then
-        freebsd.libc
-      else if libc == "oblibc" then
-        openbsd.libc
-      else if libc == "nblibc" then
-        netbsd.libc
-      else if libc == "wasilibc" then
-        wasilibc
-      else if libc == "relibc" then
-        relibc
-      else if name == "llvm" then
-        llvmPackages_20.libc
-      else
-        throw "Unknown libc ${libc}";
+      throw "Unknown libc ${libc}";
 
   threads =
     lib.optionalAttrs (stdenv.hostPlatform.isMinGW && !(stdenv.hostPlatform.useLLVM or false))
···
         "fblibc"
       ]
     then
-      libcIconv (if stdenv.hostPlatform != stdenv.buildPlatform then libc else stdenv.cc.libc)
+      libcIconv pkgs.libc
     else if stdenv.hostPlatform.isDarwin then
       darwin.libiconv
     else
···
         "musl"
       ]
     then
-      lib.getBin stdenv.cc.libc
+      lib.getBin libc
     else if stdenv.hostPlatform.isDarwin then
       lib.getBin libiconv
     else if stdenv.hostPlatform.isFreeBSD then

pkgs/top-level/darwin-packages.nix

···
       };
 
       binutils = pkgs.wrapBintoolsWith {
-        libc =
-          if stdenv.targetPlatform != stdenv.hostPlatform then targetPackages.libc else pkgs.stdenv.cc.libc;
+        inherit (targetPackages) libc;
         bintools = self.binutils-unwrapped;
       };
 

pkgs/top-level/unixtools.nix

···
       linux = pkgs.util-linux;
     };
     getconf = {
-      linux = if stdenv.hostPlatform.libc == "glibc" then pkgs.stdenv.cc.libc else pkgs.netbsd.getconf;
+      linux = if stdenv.hostPlatform.libc == "glibc" then pkgs.libc else pkgs.netbsd.getconf;
       darwin = pkgs.darwin.system_cmds;
       # I don't see any obvious arg exec in the doc/manpage
       binlore = ''
···
       '';
     };
     getent = {
-      linux =
-        if stdenv.hostPlatform.libc == "glibc" then pkgs.stdenv.cc.libc.getent else pkgs.netbsd.getent;
+      linux = if stdenv.hostPlatform.libc == "glibc" then pkgs.libc.getent else pkgs.netbsd.getent;
       darwin = pkgs.netbsd.getent;
       freebsd = pkgs.freebsd.getent;
       openbsd = pkgs.openbsd.getent;