Revert "Merge pull request #28557 from obsidiansystems/binutils-wrapper"

This reverts commit 0a944b345e89ca0096974d168f49e1c6830c3fc2, reversing
changes made to 61733ed6ccde3427016720f2e0cd191d3d95152c.

I dislike these massive stdenv changes with unclear motivation,
especially when they involve gratuitous mass renames like NIX_CC ->
NIX_BINUTILS. The previous such rename (NIX_GCC -> NIX_CC) caused
months of pain, so let's not do that again.

doc/stdenv.xml

···
+
 <chapter xmlns="http://docbook.org/ns/docbook"
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xml:id="chap-stdenv">
···
 <variablelist>
 
   <varlistentry>
-    <term>Binutils Wrapper</term>
+    <term>CC Wrapper</term>
     <listitem>
       <para>
-        Binutils Wrapper wraps the binary utilities for a bunch of miscellaneous purposes.
-        Specifically, GNU Binutils (for Linux, but a mix of cctools and GNU Binutils for Darwin), and a C standard library (glibc or Darwin's libSystem, just for the dynamic loader) are all fed in, and dependency finding, hardening (see below), and purity checks for each are handled by Binutils Wrapper.
-        Packages typically depend on CC Wrapper, which in turn (at run time) depends on binutils-wrapper.
+        CC Wrapper wraps a C toolchain for a bunch of miscellaneous purposes.
+        Specifically, a C compiler (GCC or Clang), Binutils (or the CCTools + binutils mashup when targetting Darwin), and a C standard library (glibc or Darwin's libSystem) are all fed in, and dependency finding, hardening (see below), and purity checks for each are handled by CC Wrapper.
+        Packages typically depend on only CC Wrapper, instead of those 3 inputs directly.
       </para>
       <para>
-        Binutils Wrapper was only just recently split off from CC Wrapper, so the division of labor is still being worked out.
-        For example, it shouldn't care about about the C standard library, but just take a derivation with the dynamic loader (which happens to be the glibc on linux).
-        Dependency finding however is a task both wrappers will continue to need to share, and probably the most important to understand.
+        Dependency finding is undoubtedly the main task of CC wrapper.
         It is currently accomplished by collecting directories of host-platform dependencies (i.e. <varname>buildInputs</varname> and <varname>nativeBuildInputs</varname>) in environment variables.
-        Binutils Wrapper's setup hook causes any <filename>lib</filename> and <filename>lib64</filename> subdirectories to <envar>NIX_LDFLAGS</envar>.
-        Sine CC Wrapper and Binutils Wrapper use the same strategy, most of the Binutils Wrapper code is sparsely commented and refers to CC Wrapper.
-        But CC Wrapper's code, by contrast, has quite lengthy comments.
-        Binutils Wrapper merely cites those, rather than repeating them, to avoid falling out of sync.
+        CC wrapper's setup hook causes any <filename>include</filename> subdirectory of such a dependency to be added to <envar>NIX_CFLAGS_COMPILE</envar>, and any <filename>lib</filename> and <filename>lib64</filename> subdirectories to <envar>NIX_LDFLAGS</envar>.
+        The setup hook itself contains some lengthy comments describing the exact convoluted mechanism by which this is accomplished.
       </para>
       <para>
         A final task of the setup hook is defining a number of standard environment variables to tell build systems which executables full-fill which purpose.
-        They are defined to just be the base name of the tools, under the assumption that Binutils Wrapper's binaries will be on the path.
+        They are defined to just be the base name of the tools, under the assumption that CC Wrapper's binaries will be on the path.
         Firstly, this helps poorly-written packages, e.g. ones that look for just <command>gcc</command> when <envar>CC</envar> isn't defined yet <command>clang</command> is to be used.
-        Secondly, this helps packages not get confused when cross-compiling, in which case multiple Binutils Wrappers may be simultaneous in use (targeting different platforms).
-        <envar>BUILD_</envar>- and <envar>TARGET_</envar>-prefixed versions of the normal environment variable are defined for the additional Binutils Wrappers, properly disambiguating them.
+        Secondly, this helps packages not get confused when cross-compiling, in which case multiple CC wrappers may be simultaneous in use (targeting different platforms).
+        <envar>BUILD_</envar>- and <envar>TARGET_</envar>-prefixed versions of the normal environment variable are defined for the additional CC Wrappers, properly disambiguating them.
       </para>
       <para>
-        A problem with this final task is that Binutils Wrapper is honest and defines <envar>LD</envar> as <command>ld</command>.
+        A problem with this final task is that CC Wrapper is honest and defines <envar>LD</envar> as <command>ld</command>.
         Most packages, however, firstly use the C compiler for linking, secondly use <envar>LD</envar> anyways, defining it as the C compiler, and thirdly, only so define <envar>LD</envar> when it is undefined as a fallback.
-        This triple-threat means Binutils Wrapper will break those packages, as LD is already defined as the actually linker which the package won't override yet doesn't want to use.
+        This triple-threat means CC Wrapper will break those packages, as LD is already defined as the actually linker which the package won't override yet doesn't want to use.
         The workaround is to define, just for the problematic package, <envar>LD</envar> as the C compiler.
         A good way to do this would be <command>preConfigure = "LD=$CC"</command>.
-      </para>
-    </listitem>
-  </varlistentry>
-
-  <varlistentry>
-    <term>CC Wrapper</term>
-    <listitem>
-      <para>
-        CC Wrapper wraps a C toolchain for a bunch of miscellaneous purposes.
-        Specifically, a C compiler (GCC or Clang), Binutils (or the CCTools + binutils mashup when targetting Darwin), and a C standard library (glibc or Darwin's libSystem, just for the dynamic loader) are all fed in, and dependency finding, hardening (see below), and purity checks for each are handled by Binutils Wrapper.
-        Packages typically depend on CC Wrapper, which in turn (at run time) depends on Binutils Wrapper.
-      </para>
-      <para>
-        Dependency finding is undoubtedly the main task of CC Wrapper.
-        This works just like Binutils Wrapper, except the any <filename>include</filename> subdirectory of any relevant dependency is added to <envar>NIX_CFLAGS_COMPILE</envar>.
-        The setup hook itself contains some lengthy comments describing the exact convoluted mechanism by which this is accomplished.
-      </para>
-      <para>
-        CC Wrapper also like Binutils Wrapper defines standard environment variables with the names of the tools it wraps, for the same reasons described above.
-        Importantly, while it includes a <command>cc</command> symlink to the c compiler for portability, the <envar>CC</envar> will be defined using the compiler's "real name" (i.e. <command>gcc</command> or <command>clang</command>).
-        This helps lousy build systems that inspect on the name of the compiler rather than run it.
       </para>
     </listitem>
   </varlistentry>

pkgs/applications/audio/google-musicmanager/default.nix

···
 
   buildPhase = ''
     patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "$out/opt/google/musicmanager:${stdenv.lib.makeLibraryPath [ readline ncurses stdenv.cc.libc.out qt48 stdenv.cc.cc libidn expat flac libvorbis ]}" opt/google/musicmanager/MusicManager
   '';
 

pkgs/applications/audio/google-play-music-desktop-player/default.nix

···
     cp -r ./usr/share $out
     cp -r ./usr/bin $out
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
              "$out/share/google-play-music-desktop-player/Google Play Music Desktop Player"
 
     wrapProgram $out/bin/google-play-music-desktop-player \

pkgs/applications/audio/renoise/default.nix

···
     mkdir $out/bin
     ln -s $out/renoise $out/bin/renoise
 
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) --set-rpath $out/lib $out/renoise
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) --set-rpath $out/lib $out/renoise
   '';
 
   meta = {

pkgs/applications/audio/spotify/default.nix

···
       rpath="$out/share/spotify:$libdir"
 
       patchelf \
-        --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath $rpath $out/share/spotify/spotify
 
       librarypath="${stdenv.lib.makeLibraryPath deps}:$libdir"

pkgs/applications/editors/atom/default.nix

···
 
     fixupPhase
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${atomEnv.libPath}:$out/share/atom" \
       $out/share/atom/atom
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${atomEnv.libPath}" \
       $out/share/atom/resources/app/apm/bin/node
 

pkgs/applications/editors/brackets/default.nix

···
   '';
 
   postFixup = ''
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${bracketsLibs}:$out/opt/brackets/lib" \
       $out/opt/brackets/Brackets
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${bracketsLibs}" \
       $out/opt/brackets/Brackets-node
 

pkgs/applications/editors/jetbrains/default.nix

···
           ln -s ${cmake} bin/cmake
 
           lldbLibPath=$out/clion-${version}/bin/lldb/lib
-          interp="$(cat $NIX_BINUTILS/nix-support/dynamic-linker)"
+          interp="$(cat $NIX_CC/nix-support/dynamic-linker)"
           ln -s ${ncurses.out}/lib/libncurses.so $lldbLibPath/libtinfo.so.5
 
           patchelf --set-interpreter $interp \

pkgs/applications/editors/kodestudio/default.nix

···
     postFixup = lib.optionalString (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") ''
       # Patch Binaries
       patchelf \
-          --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath "$out:${atomEnv.libPath}" \
           $out/kodestudio
       patchelf \
-          --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath ".:${stdenv.cc.libc}/lib:${xorg.libXinerama}/lib:${xorg.libX11}/lib:${alsaLib}/lib:${mesa}/lib:${openssl.out}/lib" \
           $out/resources/app/extensions/krom/Krom/linux/Krom
       patchelf \
-          --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath ".:${stdenv.cc.libc}/lib" \
           $out/resources/app/extensions/kha/Kha/Kore/Tools/krafix/krafix-linux64
       patchelf \
-          --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath ".:${stdenv.cc.libc}/lib" \
           $out/resources/app/extensions/kha/Kha/Kore/Tools/kraffiti/kraffiti-linux64
       patchelf \
-          --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath ".:${stdenv.cc.libc}/lib:${stdenv.cc.cc.lib}/lib" \
           $out/resources/app/extensions/kha/Kha/Tools/kravur/kravur-linux64
       patchelf \
-          --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath ".:${stdenv.cc.libc}/lib:${zlib}/lib" \
           $out/resources/app/extensions/kha/Kha/Tools/haxe/haxe-linux64
       patchelf \
-          --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath ".:${stdenv.cc.libc}/lib:${libvorbis}/lib:${libogg}/lib:${flac.out}/lib" \
           $out/resources/app/extensions/kha/Kha/Tools/oggenc/oggenc-linux64
 

pkgs/applications/editors/lighttable/default.nix

···
     mv ./${name}-linux/* $out/share/LightTable
 
     patchelf \
-      --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath ${libPath}:${libPath}/lib64:$out/share/LightTable \
       $out/share/LightTable/LightTable
 

pkgs/applications/editors/sublime/default.nix

···
 
     echo ${libPath}
     patchelf \
-      --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath ${libPath}:${stdenv.cc.cc.lib}/lib${stdenv.lib.optionalString stdenv.is64bit "64"} \
       $out/sublime/sublime_text
 

pkgs/applications/editors/sublime3/default.nix

···
     buildPhase = ''
       for i in sublime_text plugin_host crash_reporter; do
         patchelf \
-          --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath ${libPath}:${stdenv.cc.cc.lib}/lib${stdenv.lib.optionalString stdenv.is64bit "64"} \
           $i
       done

pkgs/applications/editors/typora/default.nix

···
 
   postFixup = ''
      patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "$out/share/typora:${rpath}" "$out/share/typora/Typora"
 
     ln -s "$out/share/typora/Typora" "$out/bin/typora"

pkgs/applications/editors/vscode/default.nix

···
 
     postFixup = lib.optionalString (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") ''
       patchelf \
-        --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath "${rpath}" \
         $out/lib/vscode/code
     '';

pkgs/applications/graphics/draftsight/default.nix

···
     mkdir $out/bin
     for exe in DraftSight dsHttpApiController dsHttpApiService FxCrashRptApp HelpGuide; do
       echo "Patching $exe..."
-      patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
                --set-rpath $libPath:\$ORIGIN/../Libraries \
                $out/draftsight/opt/dassault-systemes/DraftSight/Linux/$exe
       makeWrapper $out/draftsight/opt/dassault-systemes/DraftSight/Linux/$exe \

pkgs/applications/misc/adobe-reader/builder.sh

···
 # More pointless files.
 rm $p/bin/UNINSTALL
 
-patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
     --set-rpath $libPath \
     $p/Reader/intellinux/bin/acroread
 

pkgs/applications/misc/googleearth/default.nix

···
     rm $out/bin/google-earth $out/opt/google/earth/free/google-earth
     ln -s $out/opt/google/earth/free/googleearth $out/bin/google-earth
 
-    patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${fullPath}:\$ORIGIN" \
       $out/opt/google/earth/free/googleearth-bin
 

pkgs/applications/misc/houdini/runtime.nix

···
     echo "export QT_XKB_CONFIG_ROOT="${xkeyboardconfig}/share/X11/xkb"" >> $out/houdini/sbin/app_init.sh
   '';
   postFixup = ''
-    INTERPRETER="$(cat "$NIX_BINUTILS/nix-support/dynamic-linker")"
+    INTERPRETER="$(cat "$NIX_CC"/nix-support/dynamic-linker)"
     for BIN in $(find $out/bin -type f -executable); do
       if patchelf $BIN 2>/dev/null ; then
         echo "Patching ELF $BIN"

pkgs/applications/misc/hyper/default.nix

···
     mkdir -p "$out/bin"
     mv opt "$out/"
     ln -s "$out/opt/Hyper/hyper" "$out/bin/hyper"
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" --set-rpath "${libPath}:\$ORIGIN" "$out/opt/Hyper/hyper"
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath "${libPath}:\$ORIGIN" "$out/opt/Hyper/hyper"
     mv usr/* "$out/"
   '';
   dontPatchELF = true;

pkgs/applications/misc/ipmiview/default.nix

···
    buildPhase = with xorg; ''
      patchelf --set-rpath "${stdenv.lib.makeLibraryPath [ libX11 libXext libXrender libXtst libXi ]}" ./jre/lib/amd64/xawt/libmawt.so
      patchelf --set-rpath "${gcc.cc}/lib" ./libiKVM64.so
-     patchelf --set-rpath "${stdenv.lib.makeLibraryPath [ libXcursor libX11 libXext libXrender libXtst libXi ]}" --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" ./jre/bin/javaws
-     patchelf --set-rpath "${gcc.cc}/lib:$out/jre/lib/amd64/jli" --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" ./jre/bin/java
+     patchelf --set-rpath "${stdenv.lib.makeLibraryPath [ libXcursor libX11 libXext libXrender libXtst libXi ]}" --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" ./jre/bin/javaws
+     patchelf --set-rpath "${gcc.cc}/lib:$out/jre/lib/amd64/jli" --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" ./jre/bin/java
    '';
 
    installPhase = ''

pkgs/applications/misc/kdbplus/default.nix

···
     mkdir -p $out/bin $out/libexec
 
     patchelf \
-      --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath ${libPath} \
       ./q/l32/q
     mv ./q/l32/q $out/libexec/q

pkgs/applications/misc/kiwix/default.nix

···
   postInstall = ''
     cp -r src/dependencies/xulrunner $out/lib/kiwix
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/lib/kiwix/xulrunner/xulrunner
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/lib/kiwix/xulrunner/xulrunner
 
     rm $out/bin/kiwix
     makeWrapper $out/lib/kiwix/kiwix-launcher $out/bin/kiwix \

pkgs/applications/misc/rescuetime/default.nix

···
     cp usr/bin/rescuetime $out/bin
 
     ${patchelf}/bin/patchelf \
-      --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       $out/bin/rescuetime
 
     wrapProgram $out/bin/rescuetime \

pkgs/applications/misc/simplenote/default.nix

···
 
     fixupPhase
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${libPath}:$out/share/simplenote" \
       $out/share/simplenote/simplenote
 

pkgs/applications/networking/bittorrentsync/generic.nix

···
 
   installPhase = ''
     install -D btsync "$out/bin/btsync"
-    patchelf --interpreter "$(< $NIX_BINUTILS/nix-support/dynamic-linker)" --set-rpath ${libPath} "$out/bin/btsync"
+    patchelf --interpreter "$(< $NIX_CC/nix-support/dynamic-linker)" --set-rpath ${libPath} "$out/bin/btsync"
   '';
 
   meta = {

pkgs/applications/networking/browsers/firefox-bin/default.nix

···
         updater crashreporter webapprt-stub
       do
         if [ -e "$out/usr/lib/firefox-bin-${version}/$executable" ]; then
-          patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
             "$out/usr/lib/firefox-bin-${version}/$executable"
         fi
       done

pkgs/applications/networking/browsers/google-chrome/default.nix

···
 
     for elf in $out/share/google/$appname/{chrome,chrome-sandbox,nacl_helper}; do
       patchelf --set-rpath $rpath $elf
-      patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $elf
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $elf
     done
   '';
 

pkgs/applications/networking/browsers/mozilla-plugins/flashplayer/default.nix

···
       $out/lib${lib_suffix}/kde4/kcm_adobe_flash_player.so
 
     patchelf \
-      --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
       --set-rpath "$rpath" \
       $out/bin/flash-player-properties
   '';

pkgs/applications/networking/browsers/mozilla-plugins/flashplayer/standalone.nix

···
     cp -pv flashplayer${lib.optionalString debug "debugger"} $out/bin
 
     patchelf \
-      --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
       --set-rpath "$rpath" \
       $out/bin/flashplayer${lib.optionalString debug "debugger"}
   '';

pkgs/applications/networking/browsers/mozilla-plugins/google-talk-plugin/default.nix

···
       cp -prd opt/google/talkplugin/{data,GoogleTalkPlugin,locale,remoting24x24.png,windowpicker.glade} $out/libexec/google/talkplugin/
 
       patchelf \
-        --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath "${rpathProgram}:${stdenv.cc.cc.lib}/lib64" \
         $out/libexec/google/talkplugin/GoogleTalkPlugin
 

pkgs/applications/networking/browsers/opera/default.nix

···
     | while read f
       do
         patchelf \
-          --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath "$out/lib:${rpath}" \
           "$f"
       done

pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix

···
   buildCommand = ''
     # For convenience ...
     TBB_IN_STORE=$out/share/tor-browser
-    interp=$(< $NIX_BINUTILS/nix-support/dynamic-linker)
+    interp=$(< $NIX_CC/nix-support/dynamic-linker)
 
     # Unpack & enter
     mkdir -p "$TBB_IN_STORE"

pkgs/applications/networking/browsers/vivaldi/default.nix

···
   buildPhase = ''
     echo "Patching Vivaldi binaries"
     patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${libPath}" \
       opt/vivaldi/vivaldi-bin
   '' + stdenv.lib.optionalString proprietaryCodecs ''

pkgs/applications/networking/cluster/hadoop/default.nix

···
       sed -i $n -e "s|#!/usr/bin/env bash|#! ${bash}/bin/bash|"
     done
   '' + stdenv.lib.optionalString (!stdenv.isDarwin) ''
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" bin/container-executor;
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" bin/container-executor;
   '';
 
   installPhase = ''

pkgs/applications/networking/dropbox/default.nix

···
   '';
 
   preFixup = ''
-    INTERP=$(cat $NIX_BINUTILS/nix-support/dynamic-linker)
+    INTERP=$(cat $NIX_CC/nix-support/dynamic-linker)
     RPATH="${ldpath}:$out/${appdir}"
     getType='s/ *Type: *\([A-Z]*\) (.*/\1/'
     find "$out/${appdir}" -type f -print | while read obj; do

pkgs/applications/networking/instant-messengers/discord/default.nix

···
 
         # Copying how adobe-reader does it,
         # see pkgs/applications/misc/adobe-reader/builder.sh
-        patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
                  --set-rpath "$out/opt/discord:$libPath"                                   \
                  $out/opt/discord/Discord
 

pkgs/applications/networking/instant-messengers/franz/default.nix

···
   '';
 
   installPhase = ''
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" Franz
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" Franz
     patchelf --set-rpath "$out/opt/franz:${stdenv.lib.makeLibraryPath deps}" Franz
 
     mkdir -p $out/bin $out/opt/franz

pkgs/applications/networking/instant-messengers/hipchat/default.nix

···
     mv usr/share $out
 
     for file in $(find $d -type f); do
-        patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $file || true
+        patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $file || true
         patchelf --set-rpath ${rpath}:$out/libexec/hipchat/lib:\$ORIGIN $file || true
     done
 

pkgs/applications/networking/instant-messengers/messenger-for-desktop/default.nix

···
 
     # patch the binaries
     for file in $(find $out -type f \( -perm /0111 -o -name \*.so\* \) ); do
-      patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$file" || true
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$file" || true
       patchelf --set-rpath ${rpath}:$out/libexec $file || true
     done
 

pkgs/applications/networking/instant-messengers/rambox/default.nix

···
   dontPatchELF = true;
 
   installPhase = ''
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" rambox
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" rambox
     patchelf --set-rpath "$out/opt/rambox:${stdenv.lib.makeLibraryPath deps}" rambox
 
     mkdir -p $out/bin $out/opt/rambox

pkgs/applications/networking/instant-messengers/skypeforlinux/default.nix

···
 
   postFixup = ''
      patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "$out/share/skypeforlinux:${rpath}" "$out/share/skypeforlinux/skypeforlinux"
 
     ln -s "$out/share/skypeforlinux/skypeforlinux" "$out/bin/skypeforlinux"

pkgs/applications/networking/instant-messengers/slack/default.nix

···
     chmod -R g-w $out
 
     for file in $(find $out -type f \( -perm /0111 -o -name \*.so\* \) ); do
-      patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$file" || true
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$file" || true
       patchelf --set-rpath ${rpath}:$out/lib/slack $file || true
     done
 

pkgs/applications/networking/instant-messengers/teamspeak/client.nix

···
       mv ts3client_linux_${arch} ts3client
       echo "patching ts3client..."
       patchelf \
-        --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath ${stdenv.lib.makeLibraryPath deps}:$(cat $NIX_CC/nix-support/orig-cc)/${libDir} \
         --force-rpath \
         ts3client

pkgs/applications/networking/instant-messengers/teamspeak/server.nix

···
     ''
       echo "patching ts3server"
       patchelf \
-        --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath $(cat $NIX_CC/nix-support/orig-cc)/${libDir} \
         --force-rpath \
         ts3server
       cp tsdns/tsdnsserver tsdnsserver
       patchelf \
-        --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath $(cat $NIX_CC/nix-support/orig-cc)/${libDir} \
         --force-rpath \
         tsdnsserver

pkgs/applications/networking/instant-messengers/viber/default.nix

···
     chmod -R g-w $out
 
     for file in $(find $out -type f \( -perm /0111 -o -name \*.so\* \) ); do
-      patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$file" || true
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$file" || true
       patchelf --set-rpath $libPath:$out/opt/viber/lib $file || true
     done
 

pkgs/applications/networking/instant-messengers/zoom-us/default.nix

···
     mkdir -p $out/bin
     cp -ar * $packagePath
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)"  $packagePath/zoom
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)"  $packagePath/QtWebEngineProcess
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)"  $packagePath/qtdiag
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)"  $packagePath/zopen
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)"  $packagePath/zoom
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)"  $packagePath/QtWebEngineProcess
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)"  $packagePath/qtdiag
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)"  $packagePath/zopen
     # included from https://github.com/NixOS/nixpkgs/commit/fc218766333a05c9352b386e0cbb16e1ae84bf53
     # it works for me without it, but, well...
     paxmark m $packagePath/zoom

pkgs/applications/networking/insync/default.nix

···
   buildInputs = [ makeWrapper ];
 
   postPatch = ''
-    patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" client/insync-portable
+    patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" client/insync-portable
   '';
 
   installPhase = ''

pkgs/applications/networking/mailreaders/nylas-mail-bin/default.nix

···
 
     # Patch binaries
     binrp=$(patchelf --print-rpath $out/share/nylas-mail/nylas)
-    patchelf --interpreter $(cat "$NIX_BINUTILS/nix-support/dynamic-linker") \
+    patchelf --interpreter $(cat "$NIX_CC"/nix-support/dynamic-linker) \
       --set-rpath $binrp:$out/lib:${stdenv.cc.cc.lib}/lib:${lib.makeLibraryPath propagatedBuildInputs } \
       $out/share/nylas-mail/nylas
 
···
 
     wrapProgram $out/share/nylas-mail/resources/apm/bin/apm \
       --set PATH "${coreutils}/bin"
-    patchelf --interpreter $(cat "$NIX_BINUTILS/nix-support/dynamic-linker") \
+    patchelf --interpreter $(cat "$NIX_CC"/nix-support/dynamic-linker) \
       --set-rpath ${gcc-unwrapped.lib}/lib $out/share/nylas-mail/resources/apm/bin/node
   '';
 

pkgs/applications/networking/mailreaders/thunderbird-bin/default.nix

···
       for executable in \
         thunderbird crashreporter thunderbird-bin plugin-container updater
       do
-        patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           "$out/usr/lib/thunderbird-bin-${version}/$executable"
       done
 

pkgs/applications/networking/remote/anydesk/default.nix

···
 
   postFixup = ''
     patchelf \
-      --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
       --set-rpath "${libPath}" \
       $out/bin/anydesk
 

pkgs/applications/networking/remote/citrix-receiver/default.nix

···
         echo "Patching ELF intrepreter and rpath for $f"
         chmod u+w "$f"
         patchelf \
-          --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
           --set-rpath "$ICAInstDir:$libPath" "$f"
       done
 

pkgs/applications/networking/resilio-sync/default.nix

···
   installPhase = ''
     install -D rslsync "$out/bin/rslsync"
     patchelf \
-      --interpreter "$(< $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(< $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath ${libPath} "$out/bin/rslsync"
   '';
 

pkgs/applications/office/marp/default.nix

···
   '';
 
   postFixup = ''
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${atomEnv.libPath}:${stdenv.lib.makeLibraryPath [ libXScrnSaver ]}:$out/lib/marp" \
       $out/bin/Marp
   '';

pkgs/applications/office/moneyplex/default.nix

···
         ${coreutils}/bin/cp "\$MDIR/moneyplex" "\$MDIR/moneyplex.patched"
         ${coreutils}/bin/chmod 0755 "\$MDIR/moneyplex.patched"
     fi
-    if [ ! \`${patchelf}/bin/patchelf --print-interpreter \$MDIR/moneyplex.patched\` = $(cat $NIX_BINUTILS/nix-support/dynamic-linker) ] ||
+    if [ ! \`${patchelf}/bin/patchelf --print-interpreter \$MDIR/moneyplex.patched\` = $(cat $NIX_CC/nix-support/dynamic-linker) ] ||
        [ ! \`${patchelf}/bin/patchelf --print-rpath \$MDIR/moneyplex.patched\` = "${libPath}" ]; then
-        ${patchelf}/bin/patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) --set-rpath "${libPath}" "\$MDIR/moneyplex.patched"
+        ${patchelf}/bin/patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) --set-rpath "${libPath}" "\$MDIR/moneyplex.patched"
     fi
 
     exec \$MDIR/moneyplex.patched

pkgs/applications/office/wpsoffice/default.nix

···
     mkdir $out/bin
     for i in wps wpp et; do
       patchelf \
-        --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --force-rpath --set-rpath "$prefix/office6:$libPath" \
         $prefix/office6/$i
 

pkgs/applications/science/electronics/eagle/default.nix

···
     gcc -shared -fPIC -DEAGLE_PATH=\"$out/eagle-${version}\" ${./eagle_fixer.c} -o "$out"/lib/eagle_fixer.so -ldl
 
     # Make wrapper script
-    dynlinker="$(cat $NIX_BINUTILS/nix-support/dynamic-linker)"
+    dynlinker="$(cat $NIX_CC/nix-support/dynamic-linker)"
     mkdir -p "$out"/bin
     cat > "$out"/bin/eagle << EOF
     #!${stdenv.shell}

pkgs/applications/science/logic/saw-tools/default.nix

···
 
   fixupPhase = ''
     for x in bin/bcdump bin/extcore-info bin/jss bin/llvm-disasm bin/lss bin/saw; do
-      patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath "$out/lib:${libPath}" $out/$x;
     done
   '';

pkgs/applications/science/logic/tptp/default.nix

···
     substituteInPlace $sharedir/TPTP2X/tptp2X_install --replace /bin/mv mv
     tcsh $sharedir/TPTP2X/tptp2X_install -default
 
-    patchelf --interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) $sharedir/Scripts/tptp4X
+    patchelf --interpreter $(cat $NIX_CC/nix-support/dynamic-linker) $sharedir/Scripts/tptp4X
 
     mkdir -p $out/bin
     ln -s $sharedir/TPTP2X/tptp2X $out/bin

pkgs/applications/science/logic/verifast/default.nix

···
     ] + ":${stdenv.cc.cc.lib}/lib64";
 
   patchExe = x: ''
-    patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath ${libPath} ${x}
   '';
 in

pkgs/applications/science/math/mathematica/10.nix

···
         echo "patching $f executable <<"
         patchelf --shrink-rpath "$f"
         patchelf \
-	  --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+	  --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath "$(patchelf --print-rpath "$f"):${ldpath}" \
           "$f" \
           && patchelf --shrink-rpath "$f" \

pkgs/applications/science/math/mathematica/9.nix

···
       elif [ "$type" == "EXEC" ]; then
         echo "patching $f executable <<"
         patchelf \
-            --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+            --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
             --set-rpath "${ldpath}" \
             "$f"
         patchelf --shrink-rpath "$f"

pkgs/applications/science/math/mathematica/default.nix

···
         echo "patching $f executable <<"
         patchelf --shrink-rpath "$f"
         patchelf \
-	  --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+	  --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath "$(patchelf --print-rpath "$f"):${ldpath}" \
           "$f" \
           && patchelf --shrink-rpath "$f" \

pkgs/applications/science/math/scilab-bin/default.nix

···
     fullLibPath="$sci/lib/scilab:$sci/lib/thirdparty:$libPath"
     fullLibPath="$fullLibPath:$sci/lib/thirdparty/redist"
 
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
              --set-rpath "$fullLibPath" bin/scilab-bin
     find . -name '*.so' -type f | while read file; do
       patchelf --set-rpath "$fullLibPath" "$file" 2>/dev/null

pkgs/applications/science/medicine/aliza/default.nix

···
     libs = stdenv.lib.makeLibraryPath [ qt4 zlib stdenv.cc.cc libSM libICE libX11 libXext libXt mesa ];
   in ''
     ${patchelf}/bin/patchelf \
-      --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       $out/bin/aliza
 
     ${patchelf}/bin/patchelf \
-      --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       $out/bin/aliza-vtkvol
 
     wrapProgram $out/bin/aliza \

pkgs/applications/science/programming/fdr/default.nix

···
 
     for b in fdr4 _fdr4 refines _refines cspmprofiler cspmexplorerprof
     do
-      patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
         --set-rpath "$libPath:$out/lib" \
         "$out/bin/$b"
     done

pkgs/applications/taxes/aangifte-2006/builder.sh

···
 buildPhase() {
     for i in bin/*; do
         patchelf \
-            --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+            --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
             --set-rpath $libX11/lib:$libXext/lib \
             $i
     done

pkgs/applications/taxes/aangifte-2007/builder.sh

···
 buildPhase() {
     for i in bin/*; do
         patchelf \
-            --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+            --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
             --set-rpath $libX11/lib:$libXext/lib:$libSM/lib:$(cat $NIX_CC/nix-support/orig-cc)/lib \
             $i
     done

pkgs/applications/taxes/aangifte-2008/builder.sh

···
 buildPhase() {
     for i in bin/*; do
         patchelf \
-            --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+            --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
             --set-rpath $libX11/lib:$libXext/lib:$libSM/lib:$(cat $NIX_CC/nix-support/orig-cc)/lib \
             $i
     done

pkgs/applications/taxes/aangifte-2009/default.nix

···
     ''
       for i in bin/*; do
           patchelf \
-              --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+              --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
               --set-rpath ${stdenv.lib.makeLibraryPath [ libX11 libXext libSM ]}:$(cat $NIX_CC/nix-support/orig-cc)/lib \
               $i
       done

pkgs/applications/taxes/aangifte-2010/default.nix

···
     ''
       for i in bin/*; do
           patchelf \
-              --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+              --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
               --set-rpath ${stdenv.lib.makeLibraryPath [ libX11 libXext libSM ]}:$(cat $NIX_CC/nix-support/orig-cc)/lib \
               $i
       done

pkgs/applications/taxes/aangifte-2011/default.nix

···
     ''
       for i in bin/*; do
           patchelf \
-              --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+              --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
               --set-rpath ${stdenv.lib.makeLibraryPath [ libX11 libXext libSM ]}:$(cat $NIX_CC/nix-support/orig-cc)/lib \
               $i
       done

pkgs/applications/taxes/aangifte-2012/default.nix

···
     ''
       for i in bin/*; do
           patchelf \
-              --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+              --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
               --set-rpath ${stdenv.lib.makeLibraryPath [ libX11 libXext libSM ]}:$(cat $NIX_CC/nix-support/orig-cc)/lib \
               $i
       done

pkgs/applications/taxes/aangifte-2013-wa/default.nix

···
     ''
       for i in bin/*; do
           patchelf \
-              --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+              --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
               --set-rpath ${stdenv.lib.makeLibraryPath [ libX11 libXext libSM ]}:$(cat $NIX_CC/nix-support/orig-cc)/lib \
               $i
       done

pkgs/applications/taxes/aangifte-2013/default.nix

···
     ''
       for i in bin/*; do
           patchelf \
-              --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+              --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
               --set-rpath ${stdenv.lib.makeLibraryPath [ libX11 libXext libSM ]}:$(cat $NIX_CC/nix-support/orig-cc)/lib \
               $i
       done

pkgs/applications/taxes/aangifte-2014-wa/default.nix

···
     ''
       for i in bin/*; do
           patchelf \
-              --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+              --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
               --set-rpath ${stdenv.lib.makeLibraryPath [ libX11 libXext libSM ]}:$(cat $NIX_CC/nix-support/orig-cc)/lib \
               $i
       done

pkgs/applications/taxes/aangifte-2014/default.nix

···
     ''
       for i in bin/*; do
           patchelf \
-              --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+              --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
               --set-rpath ${stdenv.lib.makeLibraryPath [ libX11 libXext libSM ]}:$(cat $NIX_CC/nix-support/orig-cc)/lib \
               $i
       done

pkgs/applications/version-management/gitkraken/default.nix

···
   '';
 
   postFixup = ''
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
              --set-rpath "$libPath:$out/opt/gitkraken" "$out/opt/gitkraken/gitkraken"
     wrapProgram $out/opt/gitkraken/gitkraken \
       --prefix LD_PRELOAD : "${makeLibraryPath [ curl ]}/libcurl.so.4" \

pkgs/applications/video/makemkv/builder.sh

···
 
 for i in ${bin} ; do
   patchelf \
-    --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
     --set-rpath $libPath \
     ${i}
 done 

pkgs/build-support/binutils-wrapper/add-flags.sh

···
-# See cc-wrapper for comments.
-var_templates_list=(
-    NIX+IGNORE_LD_THROUGH_GCC
-    NIX+LDFLAGS
-    NIX+LDFLAGS_BEFORE
-    NIX+LDFLAGS_AFTER
-    NIX+LDFLAGS_HARDEN
-)
-var_templates_bool=(
-    NIX+SET_BUILD_ID
-    NIX+DONT_SET_RPATH
-)
-
-declare -a role_infixes=()
-if [ "${NIX_BINUTILS_WRAPPER_@infixSalt@_TARGET_BUILD:-}" ]; then
-    role_infixes+=(_BUILD_)
-fi
-if [ "${NIX_BINUTILS_WRAPPER_@infixSalt@_TARGET_HOST:-}" ]; then
-    role_infixes+=(_)
-fi
-if [ "${NIX_BINUTILS_WRAPPER_@infixSalt@_TARGET_TARGET:-}" ]; then
-    role_infixes+=(_TARGET_)
-fi
-
-for var in "${var_templates_list[@]}"; do
-    mangleVarList "$var" "${role_infixes[@]}"
-done
-for var in "${var_templates_bool[@]}"; do
-    mangleVarBool "$var" "${role_infixes[@]}"
-done
-
-if [ -e @out@/nix-support/libc-ldflags ]; then
-    NIX_@infixSalt@_LDFLAGS+=" $(< @out@/nix-support/libc-ldflags)"
-fi
-
-if [ -e @out@/nix-support/libc-ldflags-before ]; then
-    NIX_@infixSalt@_LDFLAGS_BEFORE="$(< @out@/nix-support/libc-ldflags-before) $NIX_@infixSalt@_LDFLAGS_BEFORE"
-fi
-
-export NIX_BINUTILS_WRAPPER_@infixSalt@_FLAGS_SET=1

pkgs/build-support/binutils-wrapper/add-hardening.sh

···
-hardeningFlags=(relro bindnow)
-# Intentionally word-split in case 'hardeningEnable' is defined in
-# Nix. Also, our bootstrap tools version of bash is old enough that
-# undefined arrays trip `set -u`.
-if [[ -v hardeningEnable[@] ]]; then
-  hardeningFlags+=(${hardeningEnable[@]})
-fi
-hardeningLDFlags=()
-
-declare -A hardeningDisableMap
-
-# Intentionally word-split in case 'hardeningDisable' is defined in Nix.
-for flag in ${hardeningDisable[@]:-IGNORED_KEY} @hardening_unsupported_flags@
-do
-  hardeningDisableMap[$flag]=1
-done
-
-if [[ -n "${NIX_DEBUG:-}" ]]; then
-  printf 'HARDENING: disabled flags:' >&2
-  (( "${#hardeningDisableMap[@]}" )) && printf ' %q' "${!hardeningDisableMap[@]}" >&2
-  echo >&2
-fi
-
-if [[ -z "${hardeningDisableMap[all]:-}" ]]; then
-  if [[ -n "${NIX_DEBUG:-}" ]]; then
-    echo 'HARDENING: Is active (not completely disabled with "all" flag)' >&2;
-  fi
-  for flag in "${hardeningFlags[@]}"
-  do
-    if [[ -z "${hardeningDisableMap[$flag]:-}" ]]; then
-      case $flag in
-        pie)
-          if [[ ! ("$*" =~ " -shared " || "$*" =~ " -static ") ]]; then
-            if [[ -n "${NIX_DEBUG:-}" ]]; then echo HARDENING: enabling LDFlags -pie >&2; fi
-            hardeningLDFlags+=('-pie')
-          fi
-          ;;
-        relro)
-          if [[ -n "${NIX_DEBUG:-}" ]]; then echo HARDENING: enabling relro >&2; fi
-          hardeningLDFlags+=('-z' 'relro')
-          ;;
-        bindnow)
-          if [[ -n "${NIX_DEBUG:-}" ]]; then echo HARDENING: enabling bindnow >&2; fi
-          hardeningLDFlags+=('-z' 'now')
-          ;;
-        *)
-          # Ignore unsupported. Checked in Nix that at least *some*
-          # tool supports each flag.
-          ;;
-      esac
-    fi
-  done
-fi

pkgs/build-support/binutils-wrapper/default.nix

···
-# The Nixpkgs CC is not directly usable, since it doesn't know where
-# the C library and standard header files are. Therefore the compiler
-# produced by that package cannot be installed directly in a user
-# environment and used from the command line. So we use a wrapper
-# script that sets up the right environment variables so that the
-# compiler and the linker just "work".
-
-{ name ? "", stdenv, nativeTools, noLibc ? false, nativeLibc, nativePrefix ? ""
-, binutils ? null, libc ? null
-, coreutils ? null, shell ? stdenv.shell, gnugrep ? null
-, extraPackages ? [], extraBuildCommands ? ""
-, buildPackages ? {}
-, useMacosReexportHack ? false
-}:
-
-with stdenv.lib;
-
-assert nativeTools -> nativePrefix != "";
-assert !nativeTools ->
-  binutils != null && coreutils != null && gnugrep != null;
-assert !(nativeLibc && noLibc);
-assert (noLibc || nativeLibc) == (libc == null);
-
-let
-  inherit (stdenv) hostPlatform targetPlatform;
-
-  # Prefix for binaries. Customarily ends with a dash separator.
-  #
-  # TODO(@Ericson2314) Make unconditional, or optional but always true by
-  # default.
-  prefix = stdenv.lib.optionalString (targetPlatform != hostPlatform)
-                                     (targetPlatform.config + "-");
-
-  binutilsVersion = (builtins.parseDrvName binutils.name).version;
-  binutilsName = (builtins.parseDrvName binutils.name).name;
-
-  libc_bin = if libc == null then null else getBin libc;
-  libc_dev = if libc == null then null else getDev libc;
-  libc_lib = if libc == null then null else getLib libc;
-  binutils_bin = if nativeTools then "" else getBin binutils;
-  # The wrapper scripts use 'cat' and 'grep', so we may need coreutils.
-  coreutils_bin = if nativeTools then "" else getBin coreutils;
-
-  dashlessTarget = stdenv.lib.replaceStrings ["-"] ["_"] targetPlatform.config;
-
-  # See description in cc-wrapper.
-  infixSalt = dashlessTarget;
-
-  # The dynamic linker has different names on different platforms. This is a
-  # shell glob that ought to match it.
-  dynamicLinker =
-    /**/ if libc == null then null
-    else if targetPlatform.system == "i686-linux"     then "${libc_lib}/lib/ld-linux.so.2"
-    else if targetPlatform.system == "x86_64-linux"   then "${libc_lib}/lib/ld-linux-x86-64.so.2"
-    # ARM with a wildcard, which can be "" or "-armhf".
-    else if targetPlatform.isArm                      then "${libc_lib}/lib/ld-linux*.so.3"
-    else if targetPlatform.system == "aarch64-linux"  then "${libc_lib}/lib/ld-linux-aarch64.so.1"
-    else if targetPlatform.system == "powerpc-linux"  then "${libc_lib}/lib/ld.so.1"
-    else if targetPlatform.system == "mips64el-linux" then "${libc_lib}/lib/ld.so.1"
-    else if targetPlatform.system == "x86_64-darwin"  then "/usr/lib/dyld"
-    else if stdenv.lib.hasSuffix "pc-gnu" targetPlatform.config then "ld.so.1"
-    else null;
-
-  expand-response-params =
-    if buildPackages.stdenv.cc or null != null && buildPackages.stdenv.cc != "/dev/null"
-    then import ../expand-response-params { inherit (buildPackages) stdenv; }
-    else "";
-
-in
-
-stdenv.mkDerivation {
-  name = prefix
-    + (if name != "" then name else "${binutilsName}-wrapper")
-    + (stdenv.lib.optionalString (binutils != null && binutilsVersion != "") "-${binutilsVersion}");
-
-  preferLocalBuild = true;
-
-  inherit binutils_bin shell libc_bin libc_dev libc_lib coreutils_bin;
-  gnugrep_bin = if nativeTools then "" else gnugrep;
-
-  binPrefix = prefix;
-  inherit infixSalt;
-
-  outputs = [ "out" "man" ];
-
-  passthru = {
-    inherit binutils libc nativeTools nativeLibc nativePrefix prefix;
-
-    emacsBufferSetup = pkgs: ''
-      ; We should handle propagation here too
-      (mapc
-        (lambda (arg)
-          (when (file-directory-p (concat arg "/lib"))
-            (setenv "NIX_${infixSalt}_LDFLAGS" (concat (getenv "NIX_${infixSalt}_LDFLAGS") " -L" arg "/lib")))
-          (when (file-directory-p (concat arg "/lib64"))
-            (setenv "NIX_${infixSalt}_LDFLAGS" (concat (getenv "NIX_${infixSalt}_LDFLAGS") " -L" arg "/lib64"))))
-        '(${concatStringsSep " " (map (pkg: "\"${pkg}\"") pkgs)}))
-    '';
-  };
-
-  dontBuild = true;
-  dontConfigure = true;
-
-  unpackPhase = ''
-    src=$PWD
-  '';
-
-  installPhase =
-    ''
-      set -u
-
-      mkdir -p $out/bin $out/nix-support $man/nix-support
-
-      wrap() {
-        local dst="$1"
-        local wrapper="$2"
-        export prog="$3"
-        set +u
-        substituteAll "$wrapper" "$out/bin/$dst"
-        set -u
-        chmod +x "$out/bin/$dst"
-      }
-    ''
-
-    + (if nativeTools then ''
-      echo ${nativePrefix} > $out/nix-support/orig-binutils
-
-      ldPath="${nativePrefix}/bin"
-    '' else ''
-      echo $binutils_bin > $out/nix-support/orig-binutils
-
-      ldPath="${binutils_bin}/bin"
-    ''
-
-    + optionalString (targetPlatform.isSunOS && nativePrefix != "") ''
-      # Solaris needs an additional ld wrapper.
-      ldPath="${nativePrefix}/bin"
-      exec="$ldPath/${prefix}ld"
-      wrap ld-solaris ${./ld-solaris-wrapper.sh}
-    '')
-
-    + ''
-      # Create a symlink to as (the assembler).
-      if [ -e $ldPath/${prefix}as ]; then
-        ln -s $ldPath/${prefix}as $out/bin/${prefix}as
-      fi
-
-    '' + (if !useMacosReexportHack then ''
-      wrap ${prefix}ld ${./ld-wrapper.sh} ''${ld:-$ldPath/${prefix}ld}
-    '' else ''
-      ldInner="${prefix}ld-reexport-delegate"
-      wrap "$ldInner" ${./macos-sierra-reexport-hack.bash} ''${ld:-$ldPath/${prefix}ld}
-      wrap "${prefix}ld" ${./ld-wrapper.sh} "$out/bin/$ldInner"
-      unset ldInner
-    '') + ''
-
-      if [ -e ${binutils_bin}/bin/${prefix}ld.gold ]; then
-        wrap ${prefix}ld.gold ${./ld-wrapper.sh} ${binutils_bin}/bin/${prefix}ld.gold
-      fi
-
-      if [ -e ${binutils_bin}/bin/ld.bfd ]; then
-        wrap ${prefix}ld.bfd ${./ld-wrapper.sh} ${binutils_bin}/bin/${prefix}ld.bfd
-      fi
-
-      set +u
-    '';
-
-  propagatedBuildInputs = extraPackages;
-
-  setupHook = ./setup-hook.sh;
-
-  postFixup =
-    ''
-      set -u
-    ''
-
-    + optionalString (libc != null) (''
-      ##
-      ## General libc support
-      ##
-
-      echo "-L${libc_lib}/lib" > $out/nix-support/libc-ldflags
-
-      echo "${libc_lib}" > $out/nix-support/orig-libc
-      echo "${libc_dev}" > $out/nix-support/orig-libc-dev
-
-      ##
-      ## Dynamic linker support
-      ##
-
-      if [[ -z ''${dynamicLinker+x} ]]; then
-        echo "Don't know the name of the dynamic linker for platform '${targetPlatform.config}', so guessing instead." >&2
-        local dynamicLinker="${libc_lib}/lib/ld*.so.?"
-      fi
-
-      # Expand globs to fill array of options
-      dynamicLinker=($dynamicLinker)
-
-      case ''${#dynamicLinker[@]} in
-        0) echo "No dynamic linker found for platform '${targetPlatform.config}'." >&2;;
-        1) echo "Using dynamic linker: '$dynamicLinker'" >&2;;
-        *) echo "Multiple dynamic linkers found for platform '${targetPlatform.config}'." >&2;;
-      esac
-
-      if [ -n "$dynamicLinker" ]; then
-        echo $dynamicLinker > $out/nix-support/dynamic-linker
-
-    '' + (if targetPlatform.isDarwin then ''
-        printf "export LD_DYLD_PATH=%q\n" "$dynamicLinker" >> $out/nix-support/setup-hook
-    '' else ''
-        if [ -e ${libc_lib}/lib/32/ld-linux.so.2 ]; then
-          echo ${libc_lib}/lib/32/ld-linux.so.2 > $out/nix-support/dynamic-linker-m32
-        fi
-
-        local ldflagsBefore=(-dynamic-linker "$dynamicLinker")
-    '') + ''
-      fi
-
-      # The dynamic linker is passed in `ldflagsBefore' to allow
-      # explicit overrides of the dynamic linker by callers to ld
-      # (the *last* value counts, so ours should come first).
-      printWords "''${ldflagsBefore[@]}" > $out/nix-support/libc-ldflags-before
-    '')
-
-    + optionalString (!nativeTools) ''
-
-      ##
-      ## User env support
-      ##
-
-      # Propagate the underling unwrapped binutils so that if you
-      # install the wrapper, you get tools like objdump, the manpages,
-      # etc. as well (same for any binaries of libc).
-      printWords ${binutils_bin} ${if libc == null then "" else libc_bin} > $out/nix-support/propagated-user-env-packages
-    ''
-
-    + ''
-
-      ##
-      ## Hardening support
-      ##
-
-      # some linkers on some platforms don't support specific -z flags
-      export hardening_unsupported_flags=""
-      if [[ "$($ldPath/${prefix}ld -z now 2>&1 || true)" =~ un(recognized|known)\ option ]]; then
-        hardening_unsupported_flags+=" bindnow"
-      fi
-      if [[ "$($ldPath/${prefix}ld -z relro 2>&1 || true)" =~ un(recognized|known)\ option ]]; then
-        hardening_unsupported_flags+=" relro"
-      fi
-    ''
-
-    + optionalString hostPlatform.isCygwin ''
-      hardening_unsupported_flags+=" pic"
-    ''
-
-    + ''
-      set +u
-      substituteAll ${./add-flags.sh} $out/nix-support/add-flags.sh
-      substituteAll ${./add-hardening.sh} $out/nix-support/add-hardening.sh
-      substituteAll ${../cc-wrapper/utils.sh} $out/nix-support/utils.sh
-
-      ##
-      ## Extra custom steps
-      ##
-
-    ''
-    + extraBuildCommands;
-
-  inherit dynamicLinker expand-response-params;
-
-  # for substitution in utils.sh
-  expandResponseParams = "${expand-response-params}/bin/expand-response-params";
-
-  crossAttrs = {
-    shell = shell.crossDrv + shell.crossDrv.shellPath;
-  };
-
-  meta =
-    let binutils_ = if binutils != null then binutils else {}; in
-    (if binutils_ ? meta then removeAttrs binutils.meta ["priority"] else {}) //
-    { description =
-        stdenv.lib.attrByPath ["meta" "description"] "System binary utilities" binutils_
-        + " (wrapper script)";
-  } // optionalAttrs useMacosReexportHack {
-    platforms = stdenv.lib.platforms.darwin;
-  };
-}

pkgs/build-support/binutils-wrapper/ld-solaris-wrapper.sh

···
-#!@shell@
-set -eu -o pipefail
-shopt -s nullglob
-
-declare -a args=("$@")
-# I've also tried adding -z direct and -z lazyload, but it gave too many problems with C++ exceptions :'(
-# Also made sure libgcc would not be lazy-loaded, as suggested here: https://www.illumos.org/issues/2534#note-3
-#   but still no success.
-declare -a argsBefore=(-z ignore) argsAfter=()
-
-# This loop makes sure all -L arguments are before -l arguments, or ld may complain it cannot find a library.
-# GNU binutils does not have this problem:
-#   http://stackoverflow.com/questions/5817269/does-the-order-of-l-and-l-options-in-the-gnu-linker-matter
-while (( $# )); do
-    case "${args[$i]}" in
-        -L)   argsBefore+=("$1" "$2"); shift ;;
-        -L?*) argsBefore+=("$1") ;;
-        *)    argsAfter+=("$1") ;;
-    esac
-    shift
-done
-
-# Trace:
-set -x
-exec "@ld@" "${argsBefore[@]}" "${argsAfter[@]}"

pkgs/build-support/binutils-wrapper/ld-wrapper.sh pkgs/build-support/cc-wrapper/ld-wrapper.sh

···
     PATH="@coreutils_bin@/bin"
 fi
 
-source @out@/nix-support/utils.sh
-
-if [ -z "${NIX_BINUTILS_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then
+if [ -z "${NIX_CC_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then
     source @out@/nix-support/add-flags.sh
 fi
+
+source @out@/nix-support/utils.sh
 
 
 # Optionally filter out paths not refering to the store.
···
 fi
 
 extraAfter+=($NIX_@infixSalt@_LDFLAGS_AFTER)
-
-# Choose 32-bit dynamic linker if needed
-if [ -e @out@/nix-support/dynamic-linker-m32 ]; then
-    prev=
-    for p in ${params+"${params[@]}"}; do
-        if [[ "$prev" = "-m" && "$p" = "elf_i386" ]]; then
-           extraAfter+=(
-               '-dynamic-linker'
-               "$(< @out@/nix-support/dynamic-linker-m32)"
-           )
-           break
-        fi
-        prev="$p"
-    done
-fi
 
 declare -a libDirs
 declare -A libs

pkgs/build-support/binutils-wrapper/setup-hook.sh

···
-# Binutils Wrapper hygiene
-#
-# See comments in cc-wrapper's setup hook. This works exactly the same way.
-
-binutilsWrapper_addLDVars () {
-    case $depOffset in
-        -1) local role='BUILD_' ;;
-        0)  local role='' ;;
-        1)  local role='TARGET_' ;;
-        *)  echo "binutils-wrapper: Error: Cannot be used with $depOffset-offset deps, " >2;
-            return 1 ;;
-    esac
-
-    if [[ -d "$1/lib64" && ! -L "$1/lib64" ]]; then
-        export NIX_${role}LDFLAGS+=" -L$1/lib64"
-    fi
-
-    if [[ -d "$1/lib" ]]; then
-        export NIX_${role}LDFLAGS+=" -L$1/lib"
-    fi
-}
-
-if [ -n "${crossConfig:-}" ]; then
-    export NIX_BINUTILS_WRAPPER_@infixSalt@_TARGET_BUILD=1
-    role="BUILD_"
-else
-    export NIX_BINUTILS_WRAPPER_@infixSalt@_TARGET_HOST=1
-    role=""
-fi
-
-envHooks+=(binutilsWrapper_addLDVars)
-
-# shellcheck disable=SC2157
-if [ -n "@binutils_bin@" ]; then
-    addToSearchPath _PATH @binutils_bin@/bin
-fi
-
-# shellcheck disable=SC2157
-if [ -n "@libc_bin@" ]; then
-    addToSearchPath _PATH @libc_bin@/bin
-fi
-
-# shellcheck disable=SC2157
-if [ -n "@coreutils_bin@" ]; then
-    addToSearchPath _PATH @coreutils_bin@/bin
-fi
-
-# Export tool environment variables so various build systems use the right ones.
-
-export NIX_${role}BINUTILS=@out@
-
-for CMD in \
-    ar as nm objcopy ranlib strip strings size ld windres
-do
-    if
-        PATH=$_PATH type -p "@binPrefix@$CMD" > /dev/null
-    then
-        export "${role}$(echo "$CMD" | tr "[:lower:]" "[:upper:]")=@binPrefix@${CMD}";
-    fi
-done
-
-# No local scope in sourced file
-unset role

pkgs/build-support/cc-wrapper/add-flags.sh

···
 # that case, it is cheaper/better to not repeat this step and let the forked
 # wrapped binary just inherit the work of the forker's wrapper script.
 
-var_templates_list=(
+var_templates=(
     NIX+CFLAGS_COMPILE
     NIX+CFLAGS_LINK
     NIX+CXXSTDLIB_COMPILE
     NIX+CXXSTDLIB_LINK
     NIX+GNATFLAGS_COMPILE
-)
-var_templates_bool=(
+    NIX+IGNORE_LD_THROUGH_GCC
+    NIX+LDFLAGS
+    NIX+LDFLAGS_BEFORE
+    NIX+LDFLAGS_AFTER
+
+    NIX+SET_BUILD_ID
+    NIX+DONT_SET_RPATH
     NIX+ENFORCE_NO_NATIVE
 )
 
···
 
 # We need to mangle names for hygiene, but also take parameters/overrides
 # from the environment.
-for var in "${var_templates_list[@]}"; do
-    mangleVarList "$var" "${role_infixes[@]}"
-done
-for var in "${var_templates_bool[@]}"; do
-    mangleVarBool "$var" "${role_infixes[@]}"
+for var in "${var_templates[@]}"; do
+    outputVar="${var/+/_@infixSalt@_}"
+    export ${outputVar}+=''
+    # For each role we serve, we accumulate the input parameters into our own
+    # cc-wrapper-derivation-specific environment variables.
+    for infix in "${role_infixes[@]}"; do
+        inputVar="${var/+/${infix}}"
+        if [ -v "$inputVar" ]; then
+            export ${outputVar}+="${!outputVar:+ }${!inputVar}"
+        fi
+    done
 done
 
 # `-B@out@/bin' forces cc to use ld-wrapper.sh when calling ld.
···
     NIX_@infixSalt@_GNATFLAGS_COMPILE="$(< @out@/nix-support/gnat-cflags) $NIX_@infixSalt@_GNATFLAGS_COMPILE"
 fi
 
+if [ -e @out@/nix-support/libc-ldflags ]; then
+    NIX_@infixSalt@_LDFLAGS+=" $(< @out@/nix-support/libc-ldflags)"
+fi
+
 if [ -e @out@/nix-support/cc-ldflags ]; then
-    # We don't import this above, but just tack this on know. binutils-wrapper's
-    # add-flags will not clobber it.
-    #
-    # TODO(@Ericson2314): Consider `NIX_@infixSalt@_CFLAGS_LINK` instead
     NIX_@infixSalt@_LDFLAGS+=" $(< @out@/nix-support/cc-ldflags)"
+fi
+
+if [ -e @out@/nix-support/libc-ldflags-before ]; then
+    NIX_@infixSalt@_LDFLAGS_BEFORE="$(< @out@/nix-support/libc-ldflags-before) $NIX_@infixSalt@_LDFLAGS_BEFORE"
 fi
 
 # That way forked processes will not extend these environment variables again.

pkgs/build-support/cc-wrapper/add-hardening.sh

···
   hardeningFlags+=(${hardeningEnable[@]})
 fi
 hardeningCFlags=()
+hardeningLDFlags=()
 
 declare -A hardeningDisableMap
 
···
           if [[ ! ("$*" =~ " -shared " || "$*" =~ " -static ") ]]; then
             if [[ -n "${NIX_DEBUG:-}" ]]; then echo HARDENING: enabling LDFlags -pie >&2; fi
             hardeningCFlags+=('-pie')
+            hardeningLDFlags+=('-pie')
           fi
           ;;
         pic)
···
         format)
           if [[ -n "${NIX_DEBUG:-}" ]]; then echo HARDENING: enabling format >&2; fi
           hardeningCFlags+=('-Wformat' '-Wformat-security' '-Werror=format-security')
+          ;;
+        relro)
+          if [[ -n "${NIX_DEBUG:-}" ]]; then echo HARDENING: enabling relro >&2; fi
+          hardeningLDFlags+=('-z' 'relro')
+          ;;
+        bindnow)
+          if [[ -n "${NIX_DEBUG:-}" ]]; then echo HARDENING: enabling bindnow >&2; fi
+          hardeningLDFlags+=('-z' 'now')
           ;;
         *)
           # Ignore unsupported. Checked in Nix that at least *some*

pkgs/build-support/cc-wrapper/cc-wrapper.sh

···
     PATH="@coreutils_bin@/bin:@gnugrep_bin@/bin"
 fi
 
-source @out@/nix-support/utils.sh
-
-# Flirting with a layer violation here.
-if [ -z "${NIX_BINUTILS_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then
-    source @binutils@/nix-support/add-flags.sh
-fi
-
-# Put this one second so libc ldflags take priority.
 if [ -z "${NIX_CC_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then
     source @out@/nix-support/add-flags.sh
 fi
+
+source @out@/nix-support/utils.sh
 
 
 # Parse command line options and set several variables.
···
         cppInclude=0
     elif [ "${p:0:1}" != - ]; then
         nonFlagArgs=1
+    elif [ "$p" = -m32 ]; then
+        if [ -e @out@/nix-support/dynamic-linker-m32 ]; then
+            NIX_@infixSalt@_LDFLAGS+=" -dynamic-linker $(< @out@/nix-support/dynamic-linker-m32)"
+        fi
     fi
     n+=1
 done

pkgs/build-support/cc-wrapper/default.nix

···
 # compiler and the linker just "work".
 
 { name ? "", stdenv, nativeTools, noLibc ? false, nativeLibc, nativePrefix ? ""
-, cc ? null, libc ? null, binutils, coreutils ? null, shell ? stdenv.shell
+, cc ? null, libc ? null, binutils ? null, coreutils ? null, shell ? stdenv.shell
 , zlib ? null, extraPackages ? [], extraBuildCommands ? ""
 , isGNU ? false, isClang ? cc.isClang or false, gnugrep ? null
 , buildPackages ? {}
+, useMacosReexportHack ? false
 }:
 
 with stdenv.lib;
 
 assert nativeTools -> nativePrefix != "";
 assert !nativeTools ->
-  cc != null && coreutils != null && gnugrep != null;
+  cc != null && binutils != null && coreutils != null && gnugrep != null;
 assert !(nativeLibc && noLibc);
 assert (noLibc || nativeLibc) == (libc == null);
 
+assert stdenv.targetPlatform != stdenv.hostPlatform -> runCommand != null;
+
 # For ghdl (the vhdl language provider to gcc) we need zlib in the wrapper.
 assert cc.langVhdl or false -> zlib != null;
 
···
   libc_dev = if libc == null then null else getDev libc;
   libc_lib = if libc == null then null else getLib libc;
   cc_solib = getLib cc;
+  binutils_bin = if nativeTools then "" else getBin binutils;
   # The wrapper scripts use 'cat' and 'grep', so we may need coreutils.
   coreutils_bin = if nativeTools then "" else getBin coreutils;
 
···
   # unstable implementation detail, however.
   infixSalt = dashlessTarget;
 
+  # The dynamic linker has different names on different platforms. This is a
+  # shell glob that ought to match it.
+  dynamicLinker =
+    /**/ if libc == null then null
+    else if targetPlatform.system == "i686-linux"     then "${libc_lib}/lib/ld-linux.so.2"
+    else if targetPlatform.system == "x86_64-linux"   then "${libc_lib}/lib/ld-linux-x86-64.so.2"
+    # ARM with a wildcard, which can be "" or "-armhf".
+    else if targetPlatform.isArm                      then "${libc_lib}/lib/ld-linux*.so.3"
+    else if targetPlatform.system == "aarch64-linux"  then "${libc_lib}/lib/ld-linux-aarch64.so.1"
+    else if targetPlatform.system == "powerpc-linux"  then "${libc_lib}/lib/ld.so.1"
+    else if targetPlatform.system == "mips64el-linux" then "${libc_lib}/lib/ld.so.1"
+    else if targetPlatform.system == "x86_64-darwin"  then "/usr/lib/dyld"
+    else if stdenv.lib.hasSuffix "pc-gnu" targetPlatform.config then "ld.so.1"
+    else null;
+
   expand-response-params =
     if buildPackages.stdenv.cc or null != null && buildPackages.stdenv.cc != "/dev/null"
     then import ../expand-response-params { inherit (buildPackages) stdenv; }
···
 
   preferLocalBuild = true;
 
-  inherit cc shell libc_bin libc_dev libc_lib binutils coreutils_bin;
+  inherit cc shell libc_bin libc_dev libc_lib binutils_bin coreutils_bin;
   gnugrep_bin = if nativeTools then "" else gnugrep;
 
   binPrefix = prefix;
···
 
     emacsBufferSetup = pkgs: ''
       ; We should handle propagation here too
-      (mapc
-        (lambda (arg)
-          (when (file-directory-p (concat arg "/include"))
-            (setenv "NIX_${infixSalt}_CFLAGS_COMPILE" (concat (getenv "NIX_${infixSalt}_CFLAGS_COMPILE") " -isystem " arg "/include"))))
-        '(${concatStringsSep " " (map (pkg: "\"${pkg}\"") pkgs)}))
+      (mapc (lambda (arg)
+        (when (file-directory-p (concat arg "/include"))
+          (setenv "NIX_${infixSalt}_CFLAGS_COMPILE" (concat (getenv "NIX_${infixSalt}_CFLAGS_COMPILE") " -isystem " arg "/include")))
+        (when (file-directory-p (concat arg "/lib"))
+          (setenv "NIX_${infixSalt}_LDFLAGS" (concat (getenv "NIX_${infixSalt}_LDFLAGS") " -L" arg "/lib")))
+        (when (file-directory-p (concat arg "/lib64"))
+          (setenv "NIX_${infixSalt}_LDFLAGS" (concat (getenv "NIX_${infixSalt}_LDFLAGS") " -L" arg "/lib64")))) '(${concatStringsSep " " (map (pkg: "\"${pkg}\"") pkgs)}))
     '';
   };
 
···
       echo ${if targetPlatform.isDarwin then cc else nativePrefix} > $out/nix-support/orig-cc
 
       ccPath="${if targetPlatform.isDarwin then cc else nativePrefix}/bin"
+      ldPath="${nativePrefix}/bin"
     '' else ''
       echo $cc > $out/nix-support/orig-cc
 
       ccPath="${cc}/bin"
+      ldPath="${binutils_bin}/bin"
+    ''
+
+    + optionalString (targetPlatform.isSunOS && nativePrefix != "") ''
+      # Solaris needs an additional ld wrapper.
+      ldPath="${nativePrefix}/bin"
+      exec="$ldPath/${prefix}ld"
+      wrap ld-solaris ${./ld-solaris-wrapper.sh}
     '')
 
     + ''
-      # Create symlinks to everything in the binutils wrapper.
-      for bbin in $binutils/bin/*; do
-        mkdir -p "$out/bin"
-        ln -s "$bbin" "$out/bin/$(basename $bbin)"
-      done
+      # Create a symlink to as (the assembler).  This is useful when a
+      # cc-wrapper is installed in a user environment, as it ensures that
+      # the right assembler is called.
+      if [ -e $ldPath/${prefix}as ]; then
+        ln -s $ldPath/${prefix}as $out/bin/${prefix}as
+      fi
+
+    '' + (if !useMacosReexportHack then ''
+      wrap ${prefix}ld ${./ld-wrapper.sh} ''${ld:-$ldPath/${prefix}ld}
+    '' else ''
+      ldInner="${prefix}ld-reexport-delegate"
+      wrap "$ldInner" ${./macos-sierra-reexport-hack.bash} ''${ld:-$ldPath/${prefix}ld}
+      wrap "${prefix}ld" ${./ld-wrapper.sh} "$out/bin/$ldInner"
+      unset ldInner
+    '') + ''
+
+      if [ -e ${binutils_bin}/bin/${prefix}ld.gold ]; then
+        wrap ${prefix}ld.gold ${./ld-wrapper.sh} ${binutils_bin}/bin/${prefix}ld.gold
+      fi
+
+      if [ -e ${binutils_bin}/bin/ld.bfd ]; then
+        wrap ${prefix}ld.bfd ${./ld-wrapper.sh} ${binutils_bin}/bin/${prefix}ld.bfd
+      fi
 
       # We export environment variables pointing to the wrapped nonstandard
       # cmds, lest some lousy configure script use those to guess compiler
···
       ln -s $ccPath/${prefix}ghdl $out/bin/${prefix}ghdl
     '';
 
-  propagatedBuildInputs = [ binutils ] ++ extraPackages;
+  propagatedBuildInputs = extraPackages;
 
   setupHook = ./setup-hook.sh;
 
···
       set -u
     ''
 
-    + optionalString (libc != null) ''
+    + optionalString (libc != null) (''
       ##
       ## General libc support
       ##
···
       # another -idirafter is necessary to add that directory again.
       echo "-B${libc_lib}/lib/ -idirafter ${libc_dev}/include -idirafter ${cc}/lib/gcc/*/*/include-fixed" > $out/nix-support/libc-cflags
 
+      echo "-L${libc_lib}/lib" > $out/nix-support/libc-ldflags
+
       echo "${libc_lib}" > $out/nix-support/orig-libc
       echo "${libc_dev}" > $out/nix-support/orig-libc-dev
-    ''
+
+      ##
+      ## Dynamic linker support
+      ##
+
+      if [[ -z ''${dynamicLinker+x} ]]; then
+        echo "Don't know the name of the dynamic linker for platform '${targetPlatform.config}', so guessing instead." >&2
+        local dynamicLinker="${libc_lib}/lib/ld*.so.?"
+      fi
+
+      # Expand globs to fill array of options
+      dynamicLinker=($dynamicLinker)
+
+      case ''${#dynamicLinker[@]} in
+        0) echo "No dynamic linker found for platform '${targetPlatform.config}'." >&2;;
+        1) echo "Using dynamic linker: '$dynamicLinker'" >&2;;
+        *) echo "Multiple dynamic linkers found for platform '${targetPlatform.config}'." >&2;;
+      esac
+
+      if [ -n "$dynamicLinker" ]; then
+        echo $dynamicLinker > $out/nix-support/dynamic-linker
+
+    '' + (if targetPlatform.isDarwin then ''
+        printf "export LD_DYLD_PATH=%q\n" "$dynamicLinker" >> $out/nix-support/setup-hook
+    '' else ''
+        if [ -e ${libc_lib}/lib/32/ld-linux.so.2 ]; then
+          echo ${libc_lib}/lib/32/ld-linux.so.2 > $out/nix-support/dynamic-linker-m32
+        fi
+
+        local ldflagsBefore=(-dynamic-linker "$dynamicLinker")
+    '') + ''
+      fi
+
+      # The dynamic linker is passed in `ldflagsBefore' to allow
+      # explicit overrides of the dynamic linker by callers to gcc/ld
+      # (the *last* value counts, so ours should come first).
+      printWords "''${ldflagsBefore[@]}" > $out/nix-support/libc-ldflags-before
+    '')
 
     + optionalString (!nativeTools) ''
 
···
       # Propagate the wrapped cc so that if you install the wrapper,
       # you get tools like gcov, the manpages, etc. as well (including
       # for binutils and Glibc).
+      printWords ${cc} ${binutils_bin} ${if libc == null then "" else libc_bin} > $out/nix-support/propagated-user-env-packages
       printWords ${cc.man or ""}  > $man/nix-support/propagated-user-env-packages
     ''
 
···
       ## Hardening support
       ##
 
+      # some linkers on some platforms don't support specific -z flags
       export hardening_unsupported_flags=""
+      if [[ "$($ldPath/${prefix}ld -z now 2>&1 || true)" =~ un(recognized|known)\ option ]]; then
+        hardening_unsupported_flags+=" bindnow"
+      fi
+      if [[ "$($ldPath/${prefix}ld -z relro 2>&1 || true)" =~ un(recognized|known)\ option ]]; then
+        hardening_unsupported_flags+=" relro"
+      fi
     ''
 
     + optionalString hostPlatform.isCygwin ''
···
     ''
     + extraBuildCommands;
 
-  inherit expand-response-params;
+  inherit dynamicLinker expand-response-params;
 
   # for substitution in utils.sh
   expandResponseParams = "${expand-response-params}/bin/expand-response-params";
···
     { description =
         stdenv.lib.attrByPath ["meta" "description"] "System C compiler" cc_
         + " (wrapper script)";
+  } // optionalAttrs useMacosReexportHack {
+    platforms = stdenv.lib.platforms.darwin;
   };
 }

pkgs/build-support/cc-wrapper/gnat-wrapper.sh

···
     PATH="@coreutils_bin@/bin"
 fi
 
-source @out@/nix-support/utils.sh
-
 if [ -z "${NIX_@infixSalt@_GNAT_WRAPPER_FLAGS_SET:-}" ]; then
     source @out@/nix-support/add-flags.sh
 fi
+
+source @out@/nix-support/utils.sh
 
 
 # Figure out if linker flags should be passed.  GCC prints annoying

pkgs/build-support/cc-wrapper/ld-solaris-wrapper.sh

···
+#!@shell@
+set -eu -o pipefail
+shopt -s nullglob
+
+declare -a args=("$@")
+# I've also tried adding -z direct and -z lazyload, but it gave too many problems with C++ exceptions :'(
+# Also made sure libgcc would not be lazy-loaded, as suggested here: https://www.illumos.org/issues/2534#note-3
+#   but still no success.
+declare -a argsBefore=(-z ignore) argsAfter=()
+
+# This loop makes sure all -L arguments are before -l arguments, or ld may complain it cannot find a library.
+# GNU binutils does not have this problem:
+#   http://stackoverflow.com/questions/5817269/does-the-order-of-l-and-l-options-in-the-gnu-linker-matter
+while (( $# )); do
+    case "${args[$i]}" in
+        -L)   argsBefore+=("$1" "$2"); shift ;;
+        -L?*) argsBefore+=("$1") ;;
+        *)    argsAfter+=("$1") ;;
+    esac
+    shift
+done
+
+# Trace:
+set -x
+exec "@ld@" "${argsBefore[@]}" "${argsAfter[@]}"

pkgs/build-support/cc-wrapper/macos-sierra-reexport-hack.bash

···
+#! @shell@
+
+set -eu -o pipefail
+
+path_backup="$PATH"
+if [ -n "@coreutils_bin@" ]; then
+  PATH="@coreutils_bin@/bin"
+fi
+
+declare -r recurThreshold=300
+
+declare overflowCount=0
+for ((n=0; n < $#; ++n)); do
+    case "${!n}" in
+        -l*) let overflowCount+=1 ;;
+        -reexport-l*) let overflowCount+=1 ;;
+        *) ;;
+    esac
+done
+
+declare -a allArgs=()
+
+if (( "$overflowCount" <= "$recurThreshold" )); then
+    allArgs=("$@")
+else
+    declare -a childrenLookup=() childrenLink=()
+
+    while (( $# )); do
+        case "$1" in
+            -L/*)
+                childrenLookup+=("$1")
+                allArgs+=("$1")
+                ;;
+            -L)
+                echo "cctools LD does not support '-L foo' or '-l foo'" >&2
+                exit 1
+                ;;
+            -l)
+                echo "cctools LD does not support '-L foo' or '-l foo'" >&2
+                exit 1
+                ;;
+            -lazy_library | -lazy_framework | -lto_library)
+                # We aren't linking any "azy_library", "to_library", etc.
+                allArgs+=("$1")
+                ;;
+            -lazy-l | -weak-l)    allArgs+=("$1") ;;
+                # We can't so easily prevent header issues from these.
+            -lSystem)             allArgs+=("$1") ;;
+                # Special case as indirection seems like a bad idea for something
+                # so fundamental. Can be removed for simplicity.
+            -l?* | -reexport-l?*) childrenLink+=("$1") ;;
+            *)                    allArgs+=("$1") ;;
+        esac
+
+        shift
+    done
+
+    declare n=0
+    while (( $n < "${#childrenLink[@]}" )); do
+        if [[ "${childrenLink[n]}" = -l* ]]; then
+            childrenLink[n]="-reexport${childrenLink[n]}"
+        fi
+        let ++n
+    done
+    unset n
+
+    declare -r outputNameLibless=$(basename $( \
+        if [[ -z "${outputName:+isUndefined}" ]]; then
+            echo unnamed
+        elif [[ "${outputName:0:3}" = lib ]]; then
+            echo "${outputName:3}"
+        else
+            echo "${outputName}"
+        fi))
+    declare -ra children=("$outputNameLibless-reexport-delegate-0" \
+                          "$outputNameLibless-reexport-delegate-1")
+
+    mkdir -p "$out/lib"
+
+    PATH="$PATH:@out@/bin"
+
+    symbolBloatObject=$outputNameLibless-symbol-hack.o
+    if [[ ! -e $symbolBloatObject ]]; then
+        printf '.private_extern _______child_hack_foo\nchild_hack_foo:\n' \
+            | @binPrefix@as -- -o $symbolBloatObject
+    fi
+
+    # first half of libs
+    @binPrefix@ld -macosx_version_min $MACOSX_DEPLOYMENT_TARGET -arch x86_64 -dylib \
+      -o "$out/lib/lib${children[0]}.dylib" \
+      -install_name "$out/lib/lib${children[0]}.dylib" \
+      "${childrenLookup[@]}" "$symbolBloatObject" \
+      "${childrenLink[@]:0:$((${#childrenLink[@]} / 2 ))}"
+
+    # second half of libs
+    @binPrefix@ld -macosx_version_min $MACOSX_DEPLOYMENT_TARGET -arch x86_64 -dylib \
+      -o "$out/lib/lib${children[1]}.dylib" \
+      -install_name "$out/lib/lib${children[1]}.dylib" \
+      "${childrenLookup[@]}" "$symbolBloatObject" \
+      "${childrenLink[@]:$((${#childrenLink[@]} / 2 ))}"
+
+    allArgs+=("-L$out/lib" "-l${children[0]}" "-l${children[1]}")
+fi
+
+PATH="$path_backup"
+exec @prog@ "${allArgs[@]}"

pkgs/build-support/cc-wrapper/setup-hook.sh

···
         export NIX_${role}CFLAGS_COMPILE+=" ${ccIncludeFlag:--isystem} $1/include"
     fi
 
+    if [[ -d "$1/lib64" && ! -L "$1/lib64" ]]; then
+        export NIX_${role}LDFLAGS+=" -L$1/lib64"
+    fi
+
+    if [[ -d "$1/lib" ]]; then
+        export NIX_${role}LDFLAGS+=" -L$1/lib"
+    fi
+
     if [[ -d "$1/Library/Frameworks" ]]; then
         export NIX_${role}CFLAGS_COMPILE+=" -F$1/Library/Frameworks"
     fi
···
 fi
 
 # shellcheck disable=SC2157
+if [ -n "@binutils_bin@" ]; then
+    addToSearchPath _PATH @binutils_bin@/bin
+fi
+
+# shellcheck disable=SC2157
 if [ -n "@libc_bin@" ]; then
     addToSearchPath _PATH @libc_bin@/bin
 fi
···
 
 export ${role}CC=@named_cc@
 export ${role}CXX=@named_cxx@
+
+for CMD in \
+    ar as nm objcopy ranlib strip strings size ld windres
+do
+    if
+        PATH=$_PATH type -p "@binPrefix@$CMD" > /dev/null
+    then
+        export "${role}$(echo "$CMD" | tr "[:lower:]" "[:upper:]")=@binPrefix@${CMD}";
+    fi
+done
 
 # No local scope in sourced file
 unset role

pkgs/build-support/cc-wrapper/utils.sh

···
-mangleVarList() {
-    local var="$1"
-    shift
-    local -a role_infixes=("$@")
-
-    local outputVar="${var/+/_@infixSalt@_}"
-    declare -gx ${outputVar}+=''
-    # For each role we serve, we accumulate the input parameters into our own
-    # cc-wrapper-derivation-specific environment variables.
-    for infix in "${role_infixes[@]}"; do
-        local inputVar="${var/+/${infix}}"
-        if [ -v "$inputVar" ]; then
-            export ${outputVar}+="${!outputVar:+ }${!inputVar}"
-        fi
-    done
-}
-
-mangleVarBool() {
-    local var="$1"
-    shift
-    local -a role_infixes=("$@")
-
-    local outputVar="${var/+/_@infixSalt@_}"
-    declare -gxi ${outputVar}+=''
-    for infix in "${role_infixes[@]}"; do
-        local inputVar="${var/+/${infix}}"
-        if [ -v "$inputVar" ]; then
-            let "${outputVar} |= ${!inputVar}"
-        fi
-    done
-}
-
 skip () {
     if [ -n "${NIX_DEBUG:-}" ]; then
         echo "skipping impure path $1" >&2

pkgs/desktops/maxx/default.nix

···
 
     while IFS= read -r -d ''$'\0' i; do
       if isELF "$i"; then
-        bin=`patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$i"; echo $?`
+        bin=`patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$i"; echo $?`
         patchelf --set-rpath "${stdenv.lib.makeLibraryPath deps}" "$i"
         if [ "$bin" -eq 0 ]; then
           wrapProgram "$i" \

pkgs/development/arduino/arduino-core/default.nix

···
       cp ${teensyduino_src} ./TeensyduinoInstall.${teensy_architecture}
       chmod +w ./TeensyduinoInstall.${teensy_architecture}
       upx -d ./TeensyduinoInstall.${teensy_architecture}
-      patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
           --set-rpath "${teensy_libpath}" \
           ./TeensyduinoInstall.${teensy_architecture}
       chmod +x ./TeensyduinoInstall.${teensy_architecture}
···
 
   preFixup = ''
     for file in $(find $out -type f \( -perm /0111 -o -name \*.so\* \) ); do
-        patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$file" || true
+        patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$file" || true
         patchelf --set-rpath ${rpath}:$out/lib $file || true
     done
 
···
     ${stdenv.lib.optionalString withTeensyduino ''
       # Patch the Teensy loader binary
       patchelf --debug \
-          --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
           --set-rpath "${teensy_libpath}" \
           $out/share/arduino/hardware/tools/teensy
     ''}

pkgs/development/compilers/cmucl/binary.nix

···
   buildCommand = ''
     mkdir -p $out
     tar -C $out -xjf ${dist}
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       $out/bin/lisp
   '';
 

pkgs/development/compilers/crystal/default.nix

···
         --suffix DYLD_LIBRARY_PATH : $libPath
   ''
   else ''
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
       crystal-${version}-1/embedded/bin/crystal
     patchelf --set-rpath ${ stdenv.lib.makeLibraryPath [ stdenv.cc.cc ] } \
       crystal-${version}-1/embedded/bin/crystal

pkgs/development/compilers/cudatoolkit/default.nix

···
           echo "patching $i..."
           if [[ ! $i =~ \.so ]]; then
             patchelf \
-              --set-interpreter "''$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $i
+              --set-interpreter "''$(cat $NIX_CC/nix-support/dynamic-linker)" $i
           fi
           rpath2=$rpath:$lib/lib:$out/jre/lib/amd64/jli:$out/lib:$out/lib64:$out/nvvm/lib:$out/nvvm/lib64
           patchelf --set-rpath $rpath2 --force-rpath $i

pkgs/development/compilers/gcc/builder.sh

···
         # Figure out what extra flags to pass to the gcc compilers
         # being generated to make sure that they use our glibc.
         extraFlags="$(cat $NIX_CC/nix-support/libc-cflags)"
-        extraLDFlags="$(cat $NIX_BINUTILS/nix-support/libc-ldflags) $(cat $NIX_BINUTILS/nix-support/libc-ldflags-before || true)"
+        extraLDFlags="$(cat $NIX_CC/nix-support/libc-ldflags) $(cat $NIX_CC/nix-support/libc-ldflags-before || true)"
 
         # Use *real* header files, otherwise a limits.h is generated
         # that does not include Glibc's limits.h (notably missing

pkgs/development/compilers/ghc/6.10.2-binary.nix

···
     # find editline/gmp.
     (if stdenv.isLinux then ''
       find . -type f -perm -0100 \
-          -exec patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          -exec patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath "${lib.makeLibraryPath [ libedit ncurses5 gmp ]}" {} \;
       for prog in ld ar gcc strip ranlib; do
         find . -name "setup-config" -exec sed -i "s@/usr/bin/$prog@$(type -p $prog)@g" {} \;

pkgs/development/compilers/ghc/7.0.4-binary.nix

···
     # find editline/gmp.
     stdenv.lib.optionalString stdenv.isLinux ''
       find . -type f -perm -0100 \
-          -exec patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          -exec patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath "${stdenv.lib.makeLibraryPath [ ncurses5 gmp ]}" {} \;
       sed -i "s|/usr/bin/perl|perl\x00        |" ghc-${version}/ghc/stage2/build/tmp/ghc-stage2
       sed -i "s|/usr/bin/gcc|gcc\x00        |" ghc-${version}/ghc/stage2/build/tmp/ghc-stage2

pkgs/development/compilers/ghc/7.4.2-binary.nix

···
       mkdir -p "$out/lib"
       ln -sv "${ncurses5.out}/lib/libncurses.so" "$out/lib/libncurses${stdenv.lib.optionalString stdenv.is64bit "w"}.so.5"
       find . -type f -perm -0100 \
-          -exec patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+          -exec patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath "${stdenv.lib.makeLibraryPath [ "$out" gmp ]}" {} \;
 
       paxmark m ./ghc-${version}/ghc/stage2/build/tmp/ghc-stage2

pkgs/development/compilers/gnatboot/default.nix

···
     cp -R * $out
     set +e
     for a in $out/bin/* ; do
-      patchelf --interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      patchelf --interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
         --set-rpath $(cat $NIX_CC/nix-support/orig-libc)/lib:$(cat $NIX_CC/nix-support/orig-cc)/lib64:$(cat $NIX_CC/nix-support/orig-cc)/lib $a
     done
     set -e

pkgs/development/compilers/llvm/3.4/llvm.nix

···
     "-DLLVM_BUILD_TESTS=ON"
     "-DLLVM_ENABLE_FFI=ON"
     "-DLLVM_REQUIRES_RTTI=1"
-    "-DLLVM_BINUTILS_INCDIR=${binutils.binutils.dev or binutils.binutils}/include"
+    "-DLLVM_BINUTILS_INCDIR=${binutils.dev or binutils}/include"
     "-DCMAKE_CXX_FLAGS=-std=c++11"
   ] ++ stdenv.lib.optional (!stdenv.isDarwin) "-DBUILD_SHARED_LIBS=ON";
 

pkgs/development/compilers/llvm/3.5/llvm.nix

···
   ] ++ stdenv.lib.optional enableSharedLibraries
     "-DBUILD_SHARED_LIBS=ON"
     ++ stdenv.lib.optional (!isDarwin)
-    "-DLLVM_BINUTILS_INCDIR=${binutils.binutils.dev}/include"
+    "-DLLVM_BINUTILS_INCDIR=${binutils.dev}/include"
     ++ stdenv.lib.optionals ( isDarwin) [
     "-DCMAKE_CXX_FLAGS=-stdlib=libc++"
     "-DCAN_TARGET_i386=false"

pkgs/development/compilers/llvm/3.7/llvm.nix

···
   ] ++ stdenv.lib.optional enableSharedLibraries
     "-DBUILD_SHARED_LIBS=ON"
     ++ stdenv.lib.optional (!isDarwin)
-    "-DLLVM_BINUTILS_INCDIR=${binutils.binutils.dev}/include"
+    "-DLLVM_BINUTILS_INCDIR=${binutils.dev}/include"
     ++ stdenv.lib.optionals ( isDarwin) [
     "-DLLVM_ENABLE_LIBCXX=ON"
     "-DCAN_TARGET_i386=false"

pkgs/development/compilers/llvm/3.8/llvm.nix

···
   ] ++ stdenv.lib.optional enableSharedLibraries [
     "-DLLVM_LINK_LLVM_DYLIB=ON"
   ] ++ stdenv.lib.optional (!isDarwin)
-    "-DLLVM_BINUTILS_INCDIR=${binutils.binutils.dev}/include"
+    "-DLLVM_BINUTILS_INCDIR=${binutils.dev}/include"
     ++ stdenv.lib.optionals ( isDarwin) [
     "-DLLVM_ENABLE_LIBCXX=ON"
     "-DCAN_TARGET_i386=false"

pkgs/development/compilers/llvm/3.9/llvm.nix

···
   ] ++ stdenv.lib.optional enableSharedLibraries [
     "-DLLVM_LINK_LLVM_DYLIB=ON"
   ] ++ stdenv.lib.optional (!isDarwin)
-    "-DLLVM_BINUTILS_INCDIR=${binutils.binutils.dev}/include"
+    "-DLLVM_BINUTILS_INCDIR=${binutils.dev}/include"
     ++ stdenv.lib.optionals (isDarwin) [
     "-DLLVM_ENABLE_LIBCXX=ON"
     "-DCAN_TARGET_i386=false"

pkgs/development/compilers/llvm/4/llvm.nix

···
     "-DSPHINX_WARNINGS_AS_ERRORS=OFF"
   ]
   ++ stdenv.lib.optional (!isDarwin)
-    "-DLLVM_BINUTILS_INCDIR=${binutils.binutils.dev}/include"
+    "-DLLVM_BINUTILS_INCDIR=${binutils.dev}/include"
   ++ stdenv.lib.optionals (isDarwin) [
     "-DLLVM_ENABLE_LIBCXX=ON"
     "-DCAN_TARGET_i386=false"

pkgs/development/compilers/mentor/default.nix

···
         tar --strip-components=1 -xjf "$src" -C "$out"
 
         # Patch binaries
-        interpreter="$(cat "$NIX_BINUTILS/nix-support/dynamic-linker")"
+        interpreter="$(cat "$NIX_CC"/nix-support/dynamic-linker)"
         for file in "$out"/bin/* "$out"/libexec/gcc/*/*/* "$out"/*/bin/*; do
             # Skip non-executable files
             case "$file" in

pkgs/development/compilers/mono/llvm.nix

···
 
   cmakeFlags = with stdenv; [
     "-DLLVM_ENABLE_FFI=ON"
-    "-DLLVM_BINUTILS_INCDIR=${binutils.binutils.dev}/include"
+    "-DLLVM_BINUTILS_INCDIR=${binutils.dev}/include"
     "-DCMAKE_CXX_FLAGS=-std=c++11"
   ] ++ stdenv.lib.optional (!isDarwin) "-DBUILD_SHARED_LIBS=ON";
 

pkgs/development/compilers/mozart/binary.nix

···
     tar xvf $src -C $out --strip-components=1
 
     for exe in $out/bin/{ozemulator,ozwish} ; do
-      patchelf --set-interpreter $(< $NIX_BINUTILS/nix-support/dynamic-linker) \
+      patchelf --set-interpreter $(< $NIX_CC/nix-support/dynamic-linker) \
                --set-rpath $libPath \
                $exe
     done

pkgs/development/compilers/opendylan/bin.nix

···
     mkdir -p "$out"
     tar --strip-components=1 -xjf "$src" -C "$out"
 
-    interpreter="$(cat "$NIX_BINUTILS/nix-support/dynamic-linker")"
+    interpreter="$(cat "$NIX_CC"/nix-support/dynamic-linker)"
     for a in "$out"/bin/*; do 
       patchelf --set-interpreter "$interpreter" "$a"
       patchelf --set-rpath "$out/lib:${boehmgc.out}/lib" "$a"

pkgs/development/compilers/oraclejdk/dlj-bundle-builder.sh

···
 
 # set the dynamic linker of unpack200, necessary for construct script
 echo "patching unpack200"
-patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" --set-rpath "" */bin/unpack200
+patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath "" */bin/unpack200
 
 echo "constructing JDK and JRE installations"
 if test -z "$installjdk"; then
···
 
 # set all the dynamic linkers
 find $out -type f -perm -0100 \
-    -exec patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    -exec patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
     --set-rpath "$rpath" {} \;
 
 find $out -name "*.so" -exec patchelf --set-rpath "$rpath" {} \;

pkgs/development/compilers/oraclejdk/jdk-linux-base.nix

···
 
     # set all the dynamic linkers
     find $out -type f -perm -0100 \
-        -exec patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        -exec patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath "$rpath" {} \;
 
     find $out -name "*.so" -exec patchelf --set-rpath "$rpath" {} \;

pkgs/development/compilers/rust/binaryBuild.nix

···
 
       ${optionalString (needsPatchelf && bootstrapping) ''
         patchelf \
-          --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
           "$out/bin/rustdoc"
         patchelf \
           --set-rpath "${stdenv.lib.makeLibraryPath [ curl zlib ]}" \
-          --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
           "$out/bin/cargo"
       ''}
 
       ${optionalString needsPatchelf ''
         patchelf \
-          --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
           "$out/bin/rustc"
 
       # Do NOT, I repeat, DO NOT use `wrapProgram` on $out/bin/rustc
···
       ${optionalString needsPatchelf ''
         patchelf \
           --set-rpath "${stdenv.lib.makeLibraryPath [ curl zlib ]}" \
-          --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
           "$out/bin/cargo"
       ''}
 

pkgs/development/compilers/sbcl/bootstrap.nix

···
   '';
 
   postFixup = stdenv.lib.optionalString (!stdenv.isArm && stdenv.isLinux) ''
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) $out/share/sbcl/sbcl
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) $out/share/sbcl/sbcl
   '';
 
   meta = with stdenv.lib; {

pkgs/development/compilers/tinycc/default.nix

···
     echo ${version} > VERSION
 
     configureFlagsArray+=("--cc=cc")
-    configureFlagsArray+=("--elfinterp=$(< $NIX_BINUTILS/nix-support/dynamic-linker)")
+    configureFlagsArray+=("--elfinterp=$(< $NIX_CC/nix-support/dynamic-linker)")
     configureFlagsArray+=("--crtprefix=${getLib stdenv.cc.libc}/lib")
     configureFlagsArray+=("--sysincludepaths=${getDev stdenv.cc.libc}/include:{B}/include")
     configureFlagsArray+=("--libpaths=${getLib stdenv.cc.libc}/lib")

pkgs/development/compilers/zulu/default.nix

···
 
     # set all the dynamic linkers
     find $out -type f -perm -0100 \
-        -exec patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        -exec patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath "$rpath" {} \;
 
     find $out -name "*.so" -exec patchelf --set-rpath "$rpath" {} \;

pkgs/development/interpreters/dart/default.nix

···
     mkdir -p $out
     cp -R * $out/
     echo $libPath
-    patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
              --set-rpath $libPath \
              $out/bin/dart
   '';

pkgs/development/interpreters/rebol/default.nix

···
   configurePhase = ''
     cp ${r3} make/r3-make
     chmod 777 make/r3-make
-    patchelf  --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" ./make/r3-make
+    patchelf  --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" ./make/r3-make
     cd make
     perl -pi -e 's#-m32##g' makefile
     perl -pi -e 's#sudo .*#echo#g' makefile

pkgs/development/libraries/libstdc++5/default.nix

···
     # being generated to make sure that they use our glibc.
     EXTRA_FLAGS="-I$NIX_FIXINC_DUMMY $(cat $NIX_CC/nix-support/libc-cflags) -O2"
 
-    extraLDFlags="-L$glibc_libdir -rpath $glibc_libdir"
-    extraLDFlags+=" $(cat $NIX_BINUTILS/nix-support/libc-ldflags)"
-    extraLDFlags+=" $(cat $NIX_BINUTILS/nix-support/libc-ldflags-before)"
-
+    extraLDFlags="-L$glibc_libdir -rpath $glibc_libdir $(cat $NIX_CC/nix-support/libc-ldflags) $(cat $NIX_CC/nix-support/libc-ldflags-before)"
     for i in $extraLDFlags; do
       EXTRA_FLAGS="$EXTRA_FLAGS -Wl,$i"
     done

pkgs/development/libraries/oracle-instantclient/default.nix

···
     done
 
     for exe in $out/bin/sqlplus; do
-      patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
                --force-rpath --set-rpath "$out/lib:${libaio}/lib" \
                $exe
     done

pkgs/development/libraries/wtk/builder.sh

···
     rpath=$rpath${rpath:+:}$i/lib
 done
 find $out -type f -perm -0100 \
-    -exec patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" {} \;
+    -exec patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" {} \;
 find $out -type f -perm -0100 \
     -exec patchelf --set-rpath "$rpath" {} \;

pkgs/development/misc/amdapp-sdk/default.nix

···
     }
 
     # Create wrappers
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/bin/clinfo
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/bin/clinfo
     patchelf --set-rpath ${stdenv.cc.cc.lib}/lib64:${stdenv.cc.cc.lib}/lib $out/bin/clinfo
 
     # Fix modes

pkgs/development/mobile/flashtool/default.nix

···
     ln -s ${libusb1.out}/lib/libusb-1.0.so.0 ./x10flasher_lib/linux/lib32/libusbx-1.0.so
 
     chmod +x x10flasher_lib/unyaffs.linux.x86 x10flasher_lib/bin2elf x10flasher_lib/bin2sin
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" x10flasher_lib/unyaffs.linux.x86
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" x10flasher_lib/unyaffs.linux.x86
     ln -sf unyaffs.linux.x86 x10flasher_lib/unyaffs.linux
 
     ln -s swt32.jar x10flasher_lib/swtlin/swt.jar

pkgs/development/mobile/genymotion/default.nix

···
 
   fixupPhase = ''
     patchInterpreter() {
-      patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         "$out/libexec/genymotion/$1"
     }
 

pkgs/development/tools/electron/default.nix

···
       fixupPhase
 
       patchelf \
-        --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+        --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
         --set-rpath "${atomEnv.libPath}:$out/lib/electron" \
         $out/lib/electron/electron
 

pkgs/development/tools/misc/saleae-logic/default.nix

···
     cp -r * "$out"
 
     # Patch it
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$out/Logic"
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$out/Logic"
     patchelf --set-rpath "${stdenv.cc.cc.lib}/lib:${stdenv.cc.cc.lib}/lib64:${libPath}:\$ORIGIN/Analyzers:\$ORIGIN" "$out/Logic"
 
     # Build the LD_PRELOAD library that makes Logic work from a read-only directory

pkgs/development/tools/node-webkit/nw11.nix

···
     mkdir -p $out/share/node-webkit
     cp -R * $out/share/node-webkit
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/share/node-webkit/nw
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/share/node-webkit/nwsnapshot
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/share/node-webkit/nw
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/share/node-webkit/nwsnapshot
 
     ln -s ${systemd.lib}/lib/libudev.so $out/share/node-webkit/libudev.so.0
 

pkgs/development/tools/node-webkit/nw12.nix

···
     mkdir -p $out/share/nwjs
     cp -R * $out/share/nwjs
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/share/nwjs/nw
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/share/nwjs/nwjc
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/share/nwjs/nw
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/share/nwjs/nwjc
 
     ln -s ${systemd.lib}/lib/libudev.so $out/share/nwjs/libudev.so.0
 

pkgs/development/tools/node-webkit/nw9.nix

···
     mkdir -p $out/share/node-webkit
     cp -R * $out/share/node-webkit
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/share/node-webkit/nw
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/share/node-webkit/nwsnapshot
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/share/node-webkit/nw
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/share/node-webkit/nwsnapshot
 
     ln -s ${systemd.lib}/lib/libudev.so $out/share/node-webkit/libudev.so.0
 

pkgs/development/tools/phantomjs/default.nix

···
 
   buildPhase = lib.optionalString (!stdenv.isDarwin) ''
     patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${stdenv.lib.makeLibraryPath [ freetype fontconfig stdenv.cc.cc stdenv.cc.cc openssl ]}" \
       bin/phantomjs
   '';

pkgs/development/tools/sauce-connect/default.nix

···
 
   patchPhase = stdenv.lib.optionalString stdenv.isLinux ''
     patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "$out/lib:${makeLibraryPath [zlib]}" \
       bin/sc
   '';

pkgs/development/tools/thrust/default.nix

···
     mkdir -p $out/bin
     mkdir -p $out/libexec/thrust
     unzip -d $out/libexec/thrust/ $src
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       $out/libexec/thrust/thrust_shell
     wrapProgram $out/libexec/thrust/thrust_shell \
       --prefix "LD_LIBRARY_PATH" : "${thrustEnv}/lib:${thrustEnv}/lib64"

pkgs/development/tools/unity3d/default.nix

···
       if [[ "$ftype" =~ LSB\ .*dynamically\ linked ]]; then
         if [[ "$ftype" =~ 32-bit ]]; then
           rpath="${libPath32}"
-          intp="$(cat $NIX_BINUTILS/nix-support/dynamic-linker-m32)"
+          intp="$(cat $NIX_CC/nix-support/dynamic-linker-m32)"
         else
           rpath="${libPath64}"
-          intp="$(cat $NIX_BINUTILS/nix-support/dynamic-linker)"
+          intp="$(cat $NIX_CC/nix-support/dynamic-linker)"
         fi
 
         oldRpath="$(patchelf --print-rpath "$1")"

pkgs/games/adom/default.nix

···
     done
 
     ${patchelf}/bin/patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "$out/lib:${lpath}" \
       $out/adom
 

pkgs/games/andyetitmoves/default.nix

···
 
     binName=${if commercialVersion then "AndYetItMoves" else "AndYetItMovesDemo"}
 
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) --set-rpath $fullPath $out/opt/andyetitmoves/lib/$binName
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) --set-rpath $fullPath $out/opt/andyetitmoves/lib/$binName
     cat > $out/bin/$binName << EOF
     #!/bin/sh
     cd $out/opt/andyetitmoves

pkgs/games/factorio/default.nix

···
       cp -a data $out/share/factorio
       cp -a bin/${arch.inTar}/factorio $out/bin/factorio
       patchelf \
-        --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+        --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
         $out/bin/factorio
     '';
 

pkgs/games/oilrush/default.nix

···
     cd bin
     for f in launcher_$arch libQtCoreUnigine_$arch.so.4 OilRush_$arch
     do
-      patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $f
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $f
     done
     patchelf --set-rpath ${stdenv.cc.cc.lib}/lib64:${makeLibraryPath [ stdenv.cc.cc libX11 libXext libXrender fontconfig freetype ]}\
              launcher_$arch

pkgs/games/openarena/default.nix

···
 
   installPhase = let
     gameDir = "$out/openarena-$version";
-    interpreter = "$(< \"$NIX_BINUTILS/nix-support/dynamic-linker\")";
+    interpreter = "$(< \"$NIX_CC/nix-support/dynamic-linker\")";
     libPath = stdenv.lib.makeLibraryPath [ SDL libogg libvorbis ];
   in ''
     mkdir -pv $out/bin

pkgs/games/planetaryannihilation/default.nix

···
 
     ln -s ${systemd}/lib/libudev.so.1 $out/lib/libudev.so.0
 
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$out/PA"
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" --set-rpath "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc.lib xorg.libXdamage xorg.libXfixes gtk2 glib stdenv.glibc.out "$out" xorg.libXext pango udev xorg.libX11 xorg.libXcomposite alsaLib atk nspr fontconfig cairo pango nss freetype gnome3.gconf gdk_pixbuf xorg.libXrender ]}:{stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64" "$out/host/CoherentUI_Host"
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$out/PA"
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc.lib xorg.libXdamage xorg.libXfixes gtk2 glib stdenv.glibc.out "$out" xorg.libXext pango udev xorg.libX11 xorg.libXcomposite alsaLib atk nspr fontconfig cairo pango nss freetype gnome3.gconf gdk_pixbuf xorg.libXrender ]}:{stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64" "$out/host/CoherentUI_Host"
 
     wrapProgram $out/PA --prefix LD_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc.lib stdenv.glibc.out xorg.libX11 xorg.libXcursor gtk2 glib curl "$out" ]}:${stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64"
 

pkgs/games/scrolls/default.nix

···
     cp -r ../Scrolls_Data "$out/opt/Scrolls/"
     chmod +x "$out/opt/Scrolls/Scrolls"
 
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
       --set-rpath "$libPath" "$out/opt/Scrolls/Scrolls"
 
     mkdir "$out/bin"

pkgs/games/sdlmame/default.nix

···
 
   installPhase = ''
     patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${stdenv.lib.makeLibraryPath [ alsaLib qt48 SDL fontconfig freetype SDL_ttf xorg.libX11 xorg.libXinerama stdenv.cc.cc ]}" \
       share/sdlmame/sdlmame
 

pkgs/games/terraria-server/default.nix

···
     # Fix "/lib64/ld-linux-x86-64.so.2" like references in ELF executables.
     find "$out" | while read filepath; do
       if file "$filepath" | grep -q "ELF.*executable"; then
-        echo "setting interpreter $(cat "$NIX_BINUTILS/nix-support/dynamic-linker") in $filepath"
-        patchelf --set-interpreter "$(cat "$NIX_BINUTILS/nix-support/dynamic-linker")" "$filepath"
+        echo "setting interpreter $(cat "$NIX_CC"/nix-support/dynamic-linker) in $filepath"
+        patchelf --set-interpreter "$(cat "$NIX_CC"/nix-support/dynamic-linker)" "$filepath"
         test $? -eq 0 || { echo "patchelf failed to process $filepath"; exit 1; }
       fi
     done

pkgs/games/vessel/default.nix

···
     echo @@@ 
 
     # if we call ld.so $(bin) we don't need to set the ELF interpreter, and save a patchelf step. 
-    LD_PRELOAD=./isatty.so $(cat $NIX_BINUTILS/nix-support/dynamic-linker) $src << IM_A_BOT
+    LD_PRELOAD=./isatty.so $(cat $NIX_CC/nix-support/dynamic-linker) $src << IM_A_BOT
     n
     $out/libexec/strangeloop/vessel/
     IM_A_BOT
···
     # props to Ethan Lee (the Vessel porter) for understanding
     # how $ORIGIN works in rpath. There is hope for humanity. 
     patchelf \
-      --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath $libPath:$out/libexec/strangeloop/vessel/x86/ \
       $out/libexec/strangeloop/vessel/x86/vessel.x86
 

pkgs/games/worldofgoo/default.nix

···
     mkdir -p $out/libexec/2dboy/WorldOfGoo/
     mkdir -p $out/bin
 
-    patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" --set-rpath $libPath ./WorldOfGoo.bin64
+    patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath $libPath ./WorldOfGoo.bin64
 
     cp -r * $out/libexec/2dboy/WorldOfGoo/
 

pkgs/misc/cups/drivers/kyocera/default.nix

···
     install -Dm755 English/rastertokpsl $out/lib/cups/filter/rastertokpsl
     patchelf \
       --set-rpath ${libPath} \
-      --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
       $out/lib/cups/filter/rastertokpsl
 
     mkdir -p $out/share/cups/model/Kyocera

pkgs/misc/cups/drivers/mfcl2700dnlpr/default.nix

···
         coreutils ghostscript gnugrep gnused which
       ]}
 
-    interpreter=$(cat $NIX_BINUTILS/nix-support/dynamic-linker)
+    interpreter=$(cat $NIX_CC/nix-support/dynamic-linker)
     patchelf --set-interpreter "$interpreter" $dir/inf/braddprinter
     patchelf --set-interpreter "$interpreter" $dir/lpd/brprintconflsr3
     patchelf --set-interpreter "$interpreter" $dir/lpd/rawtobr3

pkgs/misc/cups/drivers/samsung/4.00.39/builder.sh

···
 cd $out/lib/cups/filter
 for i in $(ls); do
     echo "Patching $i..."
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) $i ||
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) $i ||
       echo "Couldn't set interpreter!"
     patchelf --set-rpath $cups/lib:$gcc/lib:$glibc/lib $i  # This might not be necessary.
 done

pkgs/misc/cups/drivers/samsung/4.01.17.nix

···
       echo "Patching $exe"
       patchelf \
         --set-rpath ${libPath} \
-        --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+        --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
         $exe
     done
     unset GLOBIGNORE

pkgs/misc/cups/drivers/samsung/default.nix

···
 
   preFixup = ''
     for bin in "$out/bin/"*; do
-      patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$bin"
+      patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$bin"
       patchelf --set-rpath "$out/lib:${stdenv.lib.getLib cups}/lib" "$bin"
     done
 

pkgs/misc/drivers/gutenprint/bin.nix

···
         $out/cups/lib/backend/{canon,epson} \
         $out/sbin/cups-genppd.5.0 \
       ; do
-      patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
           --set-rpath $libPath $p
     done
     

pkgs/misc/drivers/sundtek/default.nix

···
 
     postFixup = ''
       find $out -type f -exec \
-        patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" {} \
+        patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" {} \
         patchelf --set-rpath ${rpath} {} \;
     '';
 

pkgs/misc/foldingathome/default.nix

···
   installPhase = ''
     BINFILES="fah6 mpiexec";
     for a in $BINFILES; do 
-      patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) $a
+      patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) $a
     done
     mkdir -p $out/bin
     cp $BINFILES $out/bin

pkgs/os-specific/darwin/binutils/default.nix

···
 , hostPlatform, targetPlatform
 }:
 
-# despite the name, binutils-raw is in fact wrapped.
-let binutils-unwrapped = binutils-raw.binutils; in
-
 # Make sure both underlying packages claim to have prepended their binaries
 # with the same prefix.
-assert binutils-unwrapped.prefix == cctools.prefix;
+assert binutils-raw.prefix == cctools.prefix;
 
 let
-  inherit (binutils-unwrapped) prefix;
+  inherit (binutils-raw) prefix;
   cmds = [
     "ar" "ranlib" "as" "dsymutil" "install_name_tool"
     "ld" "strip" "otool" "lipo" "nm" "strings" "size"
···
   buildCommand = ''
     mkdir -p $out/bin $out/include
 
-    ln -s ${binutils-unwrapped.out}/bin/${prefix}c++filt $out/bin/${prefix}c++filt
+    ln -s ${binutils-raw.out}/bin/${prefix}c++filt $out/bin/${prefix}c++filt
 
     # We specifically need:
     # - ld: binutils doesn't provide it on darwin
···
       ln -sf "${cctools}/bin/$i" "$out/bin/$i"
     done
 
-    for i in ${binutils-unwrapped.dev or binutils-unwrapped.out}/include/*.h; do
+    for i in ${binutils-raw.dev or binutils-raw.out}/include/*.h; do
       ln -s "$i" "$out/include/$(basename $i)"
     done
 
···
     done
 
     # FIXME: this will give us incorrect man pages for bits of cctools
-    ln -s ${binutils-unwrapped.out}/share $out/share
-    ln -s ${binutils-unwrapped.out}/lib $out/lib
+    ln -s ${binutils-raw.out}/share $out/share
+    ln -s ${binutils-raw.out}/lib $out/lib
 
     ln -s ${cctools}/libexec $out/libexec
   '';

pkgs/os-specific/linux/amdgpu-pro/default.nix

···
       "install -Dm444 usr/src/amdgpu-pro-${build}/${m}.xz $out/lib/modules/${kernel.modDirVersion}/kernel/drivers/gpu/drm/${m}.xz\n") modules)
   + ''
     mv $out/etc/vulkan $out/share
-    interpreter="$(cat $NIX_BINUTILS/nix-support/dynamic-linker)"
+    interpreter="$(cat $NIX_CC/nix-support/dynamic-linker)"
     libPath="$out/lib:$out/lib/gbm:$depLibPath"
   '' + optionalString (!stdenv.is64bit) ''
     for prog in clinfo modetest vbltest kms-universal-planes kms-steal-crtc modeprint amdgpu_test kmstest proptest; do

pkgs/os-specific/linux/dmtcp/default.nix

···
   postPatch = ''
     substituteInPlace configure \
       --replace '#define ELF_INTERPRETER "$interp"' \
-                "#define ELF_INTERPRETER \"$(cat $NIX_BINUTILS/nix-support/dynamic-linker)\""
+                "#define ELF_INTERPRETER \"$(cat $NIX_CC/nix-support/dynamic-linker)\""
   '';
 
   preConfigure = ''

pkgs/os-specific/linux/firmware/raspberrypi/default.nix

···
 
     for f in $out/bin/*; do
       if isELF "$f"; then
-        patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$f"
+        patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$f"
         patchelf --set-rpath "$out/lib" "$f"
       fi
     done

pkgs/os-specific/linux/nvidia-x11/builder-legacy173.sh

···
 
         for i in nvidia-settings nvidia-xconfig; do
 	    cp usr/bin/$i $out/bin/$i
-	    patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+	    patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
 	        --set-rpath $out/lib:$programPath:$glPath $out/bin/$i
         done
     

pkgs/os-specific/linux/nvidia-x11/builder.sh

···
         for i in nvidia-cuda-mps-control nvidia-cuda-mps-server nvidia-smi nvidia-debugdump; do
             if [ -e "$i" ]; then
                 install -Dm755 $i $bin/bin/$i
-                patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+                patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
                     --set-rpath $out/lib:$libPath $bin/bin/$i
             fi
         done

pkgs/os-specific/linux/prl-tools/default.nix

···
 
         for i in $out/bin/* $out/sbin/*; do
           patchelf \
-            --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+            --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
             --set-rpath "$out/lib:$libPath" \
             $i
         done

pkgs/servers/mattermost/default.nix

···
   '';
 
   postFixup = ''
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/bin/platform
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/bin/platform
   '';
 
   meta = with stdenv.lib; {

pkgs/servers/meteor/default.nix

···
     patch -p1 < ${./main.patch}
     popd
     substituteInPlace $out/tools/cli/main.js \
-      --replace "@INTERPRETER@" "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --replace "@INTERPRETER@" "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --replace "@RPATH@" "${lib.makeLibraryPath [ stdenv.cc.cc zlib ]}" \
       --replace "@PATCHELF@" "${patchelf}/bin/patchelf"
 
     # Patch node.
     node=$devBundle/bin/node
     patchelf \
-      --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+      --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
       --set-rpath "$(patchelf --print-rpath $node):${stdenv.cc.cc.lib}/lib" \
       $node
 
     # Patch mongo.
     for p in $devBundle/mongodb/bin/mongo{,d}; do
       patchelf \
-        --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+        --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
         --set-rpath "$(patchelf --print-rpath $p):${lib.makeLibraryPath [ stdenv.cc.cc zlib ]}" \
         $p
     done

pkgs/servers/monitoring/newrelic-sysmond/default.nix

···
   installPhase = ''
     mkdir -p $out/bin
     install -v -m755 daemon/nrsysmond.x64 $out/bin/nrsysmond
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       $out/bin/nrsysmond
   '';
 

pkgs/servers/sql/oracle-xe/default.nix

···
       \( -name '*.sh' \
       -o -path "$basedir/bin/*" \
       \) -print -exec "${patchelf}/bin/patchelf" \
-           --interpreter "$(cat "$NIX_BINUTILS/nix-support/dynamic-linker")" \
+           --interpreter "$(cat "$NIX_CC/nix-support/dynamic-linker")" \
            --set-rpath "${libs}:$out/libexec/oracle/lib" \
            --force-rpath '{}' \;
   '';

pkgs/stdenv/darwin/default.nix

···
                           extraBuildInputs,
                           allowedRequisites ? null}:
     let
-      buildPackages = lib.optionalAttrs (last ? stdenv) {
-        inherit (last) stdenv;
-      };
-
-      coreutils = { name = "coreutils-9.9.9"; outPath = bootstrapTools; };
-      gnugrep   = { name = "gnugrep-9.9.9";   outPath = bootstrapTools; };
-
-      binutils = import ../../build-support/binutils-wrapper {
-        inherit shell;
-        inherit (last) stdenv;
-
-        nativeTools  = false;
-        nativeLibc   = false;
-        inherit buildPackages coreutils gnugrep;
-        libc         = last.pkgs.darwin.Libsystem;
-        binutils     = { name = "binutils-9.9.9";  outPath = bootstrapTools; };
-      };
-
-      cc = if isNull last then "/dev/null" else import ../../build-support/cc-wrapper {
-        inherit shell;
-        inherit (last) stdenv;
-
-        nativeTools  = false;
-        nativeLibc   = false;
-        inherit buildPackages coreutils gnugrep binutils;
-        libc         = last.pkgs.darwin.Libsystem;
-        isClang      = true;
-        cc           = { name = "clang-9.9.9";     outPath = bootstrapTools; };
-      };
-
       thisStdenv = import ../generic {
         inherit config shell extraNativeBuildInputs extraBuildInputs;
         allowedRequisites = if allowedRequisites == null then null else allowedRequisites ++ [
-          cc.expand-response-params cc.binutils
+          thisStdenv.cc.expand-response-params
         ];
 
         name = "stdenv-darwin-boot-${toString step}";
···
         hostPlatform = localSystem;
         targetPlatform = localSystem;
 
-        inherit cc;
+        cc = if isNull last then "/dev/null" else import ../../build-support/cc-wrapper {
+          inherit shell;
+          inherit (last) stdenv;
+
+          nativeTools  = false;
+          nativeLibc   = false;
+          buildPackages = lib.optionalAttrs (last ? stdenv) {
+            inherit (last) stdenv;
+          };
+          libc         = last.pkgs.darwin.Libsystem;
+          isClang      = true;
+          cc           = { name = "clang-9.9.9";     outPath = bootstrapTools; };
+          binutils     = { name = "binutils-9.9.9";  outPath = bootstrapTools; };
+          coreutils    = { name = "coreutils-9.9.9"; outPath = bootstrapTools; };
+          gnugrep      = { name = "gnugrep-9.9.9";   outPath = bootstrapTools; };
+        };
 
-        preHook = lib.optionalString (shell == "${bootstrapTools}/bin/bash") ''
+        preHook = stage0.stdenv.lib.optionalString (shell == "${bootstrapTools}/bin/bash") ''
           # Don't patch #!/interpreter because it leads to retained
           # dependencies on the bootstrapTools in the final stdenv.
           dontPatchShebangs=1
···
       xz.out xz.bin libcxx libcxxabi gmp.out gnumake findutils bzip2.out
       bzip2.bin llvmPackages.llvm llvmPackages.llvm.lib zlib.out zlib.dev libffi.out coreutils ed diffutils gnutar
       gzip ncurses.out ncurses.dev ncurses.man gnused bash gawk
-      gnugrep llvmPackages.clang-unwrapped patch pcre.out gettext
-      binutils-raw.binutils.out binutils-raw.binutils.dev binutils binutils.binutils
+      gnugrep llvmPackages.clang-unwrapped patch pcre.out binutils-raw.out
+      binutils-raw.dev binutils gettext
       cc.expand-response-params
     ]) ++ (with pkgs.darwin; [
       dyld Libsystem CF cctools ICU libiconv locale

pkgs/stdenv/linux/default.nix

···
         '';
       };
       gcc-unwrapped = bootstrapTools;
-      binutils = import ../../build-support/binutils-wrapper {
-        nativeTools = false;
-        nativeLibc = false;
-        buildPackages = { };
-        libc = self.glibc;
-        inherit (self) coreutils gnugrep;
-        binutils = bootstrapTools;
-        name = "bootstrap-binutils-wrapper";
-        stdenv = self.stdenv;
-      };
+      binutils = bootstrapTools;
       coreutils = bootstrapTools;
       gnugrep = bootstrapTools;
     };
···
 
     # Rebuild binutils to use from stage2 onwards.
     overrides = self: super: {
-      binutils = super.binutils_nogold;
+      binutils = super.binutils.override { gold = false; };
       inherit (prevStage)
         ccWrapperStdenv
         glibc gcc-unwrapped coreutils gnugrep;
···
     overrides = self: super: {
       inherit (prevStage)
         ccWrapperStdenv
-        gcc-unwrapped coreutils gnugrep
+        binutils gcc-unwrapped coreutils gnugrep
         perl paxctl gnum4 bison;
       # This also contains the full, dynamically linked, final Glibc.
-      binutils = prevStage.binutils.override {
-        # Rewrap the binutils with the new glibc, so both the next
-        # stage's wrappers use it.
-        libc = self.glibc;
-      };
     };
   })
 
···
       # other purposes (binutils and top-level pkgs) too.
       inherit (prevStage) gettext gnum4 bison gmp perl glibc zlib linuxHeaders;
 
-      binutils = super.binutils.override {
-        # Don't use stdenv's shell but our own
-        shell = self.bash + "/bin/bash";
-        # Build expand-response-params with last stage like below
-        buildPackages = {
-          inherit (prevStage) stdenv;
-        };
-      };
-
       gcc = lib.makeOverridable (import ../../build-support/cc-wrapper) {
         nativeTools = false;
         nativeLibc = false;
···
       allowedRequisites = with prevStage; with lib;
         # Simple executable tools
         concatMap (p: [ (getBin p) (getLib p) ])
-          [ gzip bzip2 xz bash binutils.binutils coreutils diffutils findutils
-            gawk gnumake gnused gnutar gnugrep gnupatch patchelf ed paxctl
+          [ gzip bzip2 xz bash binutils coreutils diffutils findutils gawk
+            gnumake gnused gnutar gnugrep gnupatch patchelf ed paxctl
           ]
         # Library dependencies
         ++ map getLib (
···
         # More complicated cases
         ++ [
             glibc.out glibc.dev glibc.bin/*propagated from .dev*/ linuxHeaders
-            binutils gcc gcc.cc gcc.cc.lib gcc.expand-response-params
+            gcc gcc.cc gcc.cc.lib gcc.expand-response-params
           ]
           ++ lib.optionals (system == "aarch64-linux")
             [ prevStage.updateAutotoolsGnuConfigScriptsHook prevStage.gnu-config ];

pkgs/tools/filesystems/yandex-disk/default.nix

···
       $out/etc/bash_completion.d/yandex-disk-completion.bash
 
     ${patchelf}/bin/patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath "${zlib.out}/lib:${p.gcclib}" \
       $out/bin/yandex-disk
   '';

pkgs/tools/misc/megacli/default.nix

···
     cd $out
     unzip ${src}
     rpmextract linux/MegaCli-8.07.07-1.noarch.rpm
-    ${patchelf}/bin/patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" --set-rpath ${libPath}:$out/opt/lsi/3rdpartylibs/x86_64:$out/opt/lsi/3rdpartylibs:${stdenv.cc.cc.lib}/lib64:${stdenv.cc.cc.lib}/lib opt/MegaRAID/MegaCli/MegaCli64
+    ${patchelf}/bin/patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath ${libPath}:$out/opt/lsi/3rdpartylibs/x86_64:$out/opt/lsi/3rdpartylibs:${stdenv.cc.cc.lib}/lib64:${stdenv.cc.cc.lib}/lib opt/MegaRAID/MegaCli/MegaCli64
     wrapProgram $out/opt/MegaRAID/MegaCli/MegaCli64 --set LD_LIBRARY_PATH $out/opt/lsi/3rdpartylibs/x86_64
     ln -s $out/opt/MegaRAID/MegaCli/MegaCli64 $out/bin/MegaCli64
     eval fixupPhase

pkgs/tools/misc/ocz-ssd-guru/default.nix

···
     cp ${system}/SSDGuru $out/bin/
     rm -rf linux{32,64}
     patchelf \
-      --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       --set-rpath $libPath:$out \
       $out/bin/SSDGuru
 

pkgs/tools/misc/sam-ba/default.nix

···
     mkdir -p "$out/bin/" \
              "$out/opt/sam-ba/"
     cp -a . "$out/opt/sam-ba/"
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$out/opt/sam-ba/sam-ba${maybe64}"
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$out/opt/sam-ba/sam-ba${maybe64}"
     cat > "$out/bin/sam-ba" << EOF
     export LD_LIBRARY_PATH="${libPath}"
     exec "$out/opt/sam-ba/sam-ba${maybe64}"

pkgs/tools/misc/staruml/default.nix

···
     mv opt/staruml $out/bin
 
     ${patchelf}/bin/patchelf \
-      --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" \
+      --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       $out/bin/StarUML
 
     mkdir -p $out/lib

pkgs/tools/misc/xflux/default.nix

···
     cp  xflux "$out/bin"
   '';
   postFixup = ''
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) --set-rpath "$libPath" "$out/bin/xflux"
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) --set-rpath "$libPath" "$out/bin/xflux"
   '';
   meta = {
     description = "Adjusts your screen to emit warmer light at night";

pkgs/tools/package-management/rpm/default.nix

···
 
   buildInputs = [ cpio zlib bzip2 file libarchive nspr nss db xz python lua pkgconfig autoreconfHook ];
 
-  # rpm/rpmlib.h includes popt.h, and then the pkg-config file mentions these as
-  # linkage requirements
-  #
-  # Binutils.binutils for headers
-  propagatedBuildInputs = [
-    popt elfutils nss db bzip2 libarchive binutils binutils.binutils
-  ];
+  # rpm/rpmlib.h includes popt.h, and then the pkg-config file mentions these as linkage requirements
+  propagatedBuildInputs = [ popt elfutils nss db bzip2 libarchive binutils ];
 
   NIX_CFLAGS_COMPILE = "-I${nspr.dev}/include/nspr -I${nss.dev}/include/nss";
 

pkgs/tools/security/encryptr/default.nix

···
     cp -v lib* $out/lib
     ln -sv ${systemd.lib}/lib/libudev.so.1 $out/lib/libudev.so.0
 
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) \
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
              --set-rpath $out/lib:${rpath} \
              $out/bin/encryptr
   '';

pkgs/tools/security/enpass/default.nix

···
       	$out/share/applications/enpass.desktop
 
       for i in $out/bin/{Enpass,EnpassHelper/EnpassHelper}; do
-        patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) $i
+        patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) $i
       done
 
       # The helper's sha256 sum must match, hence the use of libredirect.

pkgs/tools/security/fprot/default.nix

···
     cp f-prot.conf.default $out/opt/f-prot/f-prot.conf
     ln -s $out/opt/f-prot/fpupdate $out/bin/fpupdate
 
-    patchelf --interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" $out/opt/f-prot/fpupdate
+    patchelf --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out/opt/f-prot/fpupdate
 
     mkdir -p $out/share/man/
     mkdir -p $out/share/man/man1

pkgs/tools/security/gorilla-bin/default.nix

···
   '';
 
   installPhase = let
-    interpreter = "$(< \"$NIX_BINUTILS/nix-support/dynamic-linker\")";
+    interpreter = "$(< \"$NIX_CC/nix-support/dynamic-linker\")";
     libPath = stdenv.lib.makeLibraryPath [ libXft libX11 freetype fontconfig libXrender libXScrnSaver libXext ];
   in ''
     mkdir -p $out/opt/password-gorilla

pkgs/tools/security/keybase-gui/default.nix

···
     chmod +x $out/bin/keybase-gui
   '';
   postFixup = ''
-    patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker) --set-rpath "${libPath}:\$ORIGIN" "$out/share/keybase/Keybase"
+    patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) --set-rpath "${libPath}:\$ORIGIN" "$out/share/keybase/Keybase"
   '';
 
   meta = with stdenv.lib; {

pkgs/tools/text/xidel/default.nix

···
   installPhase = ''
     mkdir -p "$out/bin"
     cp -a usr/* "$out/"
-    patchelf --set-interpreter "$(cat $NIX_BINUTILS/nix-support/dynamic-linker)" "$out/bin/xidel"
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$out/bin/xidel"
   '';
 
   meta = with stdenv.lib; {

pkgs/top-level/all-packages.nix

···
   emscripten = callPackage ../development/compilers/emscripten { };
 
   emscriptenfastcomp-unwrapped = callPackage ../development/compilers/emscripten-fastcomp { };
-  emscriptenfastcomp-wrapped = wrapCCWith stdenv.cc.libc stdenv.cc.binutils ''
+  emscriptenfastcomp-wrapped = wrapCCWith stdenv.cc.libc ''
     # hardening flags break WASM support
     cat > $out/nix-support/add-hardening.sh
   '' emscriptenfastcomp-unwrapped;
···
 
   clang-sierraHack = clang.override {
     name = "clang-wrapper-with-reexport-hack";
-    binutils = clang.binutils.override {
-      useMacosReexportHack = true;
-    };
+    useMacosReexportHack = true;
   };
 
   clang_4  = llvmPackages_4.clang;
···
         extraBuildCommands = ''
           echo "dontMoveLib64=1" >> $out/nix-support/setup-hook
         '';
-        # Binutils with glibc multi
-        binutils = cc.binutils.override {
-          libc = glibc_multi;
-        };
-      in wrapCCWith glibc_multi binutils extraBuildCommands (cc.cc.override {
-        stdenv = overrideCC stdenv (wrapCCWith glibc_multi binutils "" cc.cc);
+      in wrapCCWith glibc_multi extraBuildCommands (cc.cc.override {
+        stdenv = overrideCC stdenv (wrapCCWith glibc_multi "" cc.cc);
         profiledCompiler = false;
         enableMultilib = true;
       }))
···
 
   wla-dx = callPackage ../development/compilers/wla-dx { };
 
-  wrapCCWith = libc: binutils: extraBuildCommands: baseCC: ccWrapperFun {
+  wrapCCWith = libc: extraBuildCommands: baseCC: ccWrapperFun {
     nativeTools = stdenv.cc.nativeTools or false;
     nativeLibc = stdenv.cc.nativeLibc or false;
     nativePrefix = stdenv.cc.nativePrefix or "";
     cc = baseCC;
     isGNU = baseCC.isGNU or false;
     isClang = baseCC.isClang or false;
-    inherit libc binutils extraBuildCommands;
+    inherit libc extraBuildCommands;
   };
 
   ccWrapperFun = callPackage ../build-support/cc-wrapper;
-  binutilsWrapperFun = callPackage ../build-support/binutils-wrapper;
 
-  wrapCC = wrapCCWith stdenv.cc.libc stdenv.cc.binutils "";
+  wrapCC = wrapCCWith stdenv.cc.libc "";
   # legacy version, used for gnat bootstrapping
   wrapGCC-old = baseGCC: callPackage ../build-support/gcc-wrapper-old {
     nativeTools = stdenv.cc.nativeTools or false;
···
 
       inherit cc binutils libc shell name;
     };
-
-  wrapBinutils = baseBinutils: binutilsWrapperFun {
-    nativeTools = stdenv.cc.nativeTools or false;
-    nativeLibc = stdenv.cc.nativeLibc or false;
-    nativePrefix = stdenv.cc.nativePrefix or "";
-    libc = stdenv.cc.libc;
-    binutils = baseBinutils;
-    extraBuildCommands = "";
-  };
 
   # prolog
   yap = callPackage ../development/compilers/yap { };
···
     then darwin.binutils
     else binutils-raw;
 
-  binutils-raw = wrapBinutils (callPackage ../development/tools/misc/binutils {
+  binutils-raw = callPackage ../development/tools/misc/binutils {
     # FHS sys dirs presumably only have stuff for the build platform
     noSysDirs = (targetPlatform != buildPlatform) || noSysDirs;
-  });
+  };
 
   binutils_nogold = lowPrio (binutils-raw.override {
-    binutils = binutils-raw.binutils.override {
-      gold = false;
-    };
+    gold = false;
   });
 
   bison2 = callPackage ../development/tools/parsing/bison/2.x.nix { };

pkgs/top-level/darwin-packages.nix

···
 
   apple_sdk = callPackage ../os-specific/darwin/apple-sdk { };
 
-  binutils = pkgs.wrapBinutils (callPackage ../os-specific/darwin/binutils {
+  binutils = callPackage ../os-specific/darwin/binutils {
     inherit (darwin) cctools;
-  });
+  };
 
   cctools = callPackage ../os-specific/darwin/cctools/port.nix {
     inherit (darwin) libobjc maloader;

pkgs/top-level/haxe-packages.nix

···
       postFixup = ''
         for f in $out/lib/haxe/${withCommas libname}/${withCommas version}/{,project/libs/nekoapi/}bin/Linux{,64}/*; do
           chmod +w "$f"
-          patchelf --set-interpreter $(cat $NIX_BINUTILS/nix-support/dynamic-linker)   "$f" || true
+          patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker)   "$f" || true
           patchelf --set-rpath ${ stdenv.lib.makeLibraryPath [ stdenv.cc.cc ] }  "$f" || true
         done
       '';