gcc-wrapper: Get rid of builder.sh + cleanup

pkgs/build-support/gcc-wrapper/builder.sh

@@ -1,214 +0,0 @@
-source $stdenv/setup
-
-
-mkdir -p $out/bin
-mkdir -p $out/nix-support
-
-
-if test -z "$nativeLibc"; then
-    dynamicLinker="$libc/lib/$dynamicLinker"
-    echo $dynamicLinker > $out/nix-support/dynamic-linker
-
-    if test -e $libc/lib/32/ld-linux.so.2; then
-        echo $libc/lib/32/ld-linux.so.2 > $out/nix-support/dynamic-linker-m32
-    fi
-
-    # The "-B$libc/lib/" flag is a quick hack to force gcc to link
-    # against the crt1.o from our own glibc, rather than the one in
-    # /usr/lib.  (This is only an issue when using an `impure'
-    # compiler/linker, i.e., one that searches /usr/lib and so on.)
-    #
-    # Unfortunately, setting -B appears to override the default search
-    # path. Thus, the gcc-specific "../includes-fixed" directory is
-    # now longer searched and glibc's <limits.h> header fails to
-    # compile, because it uses "#include_next <limits.h>" to find the
-    # limits.h file in ../includes-fixed. To remedy the problem,
-    # another -idirafter is necessary to add that directory again.
-    echo "-B$libc/lib/ -idirafter $libc/include -idirafter $gcc/lib/gcc/*/*/include-fixed" > $out/nix-support/libc-cflags
-
-    echo "-L$libc/lib" > $out/nix-support/libc-ldflags
-
-    # 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).
-    echo "-dynamic-linker" $dynamicLinker > $out/nix-support/libc-ldflags-before
-fi
-
-if test -n "$nativeTools"; then
-    gccPath="$nativePrefix/bin"
-    ldPath="$nativePrefix/bin"
-else
-    if test -e "$gcc/lib64"; then
-        gccLDFlags="$gccLDFlags -L$gcc/lib64"
-    fi
-    gccLDFlags="$gccLDFlags -L$gcc/lib"
-    if [ -n "$langVhdl" ]; then
-        gccLDFlags="$gccLDFlags -L$zlib/lib"
-    fi
-    echo "$gccLDFlags" > $out/nix-support/gcc-ldflags
-
-    # GCC shows $gcc/lib in `gcc -print-search-dirs', but not
-    # $gcc/lib64 (even though it does actually search there...)..
-    # This confuses libtool.  So add it to the compiler tool search
-    # path explicitly.
-    if test -e "$gcc/lib64"; then
-        gccCFlags="$gccCFlags -B$gcc/lib64"
-    fi
-
-    # Find the gcc libraries path (may work only without multilib)
-    if [ -n "$langAda" ]; then
-        basePath=`echo $gcc/lib/*/*/*`
-        gccCFlags="$gccCFlags -B$basePath -I$basePath/adainclude"
-
-        gnatCFlags="-aI$basePath/adainclude -aO$basePath/adalib"
-        echo "$gnatCFlags" > $out/nix-support/gnat-cflags
-    fi
-    echo "$gccCFlags" > $out/nix-support/gcc-cflags
-    
-    gccPath="$gcc/bin"
-    # On Illumos/Solaris we might prefer native ld
-    if test -n "$nativePrefix"; then
-      ldPath="$nativePrefix/bin"
-    else
-      ldPath="$binutils/bin"
-    fi;
-fi
-
-
-doSubstitute() {
-    local src=$1
-    local dst=$2
-    local ld="$ldPath/ld"
-    if $ld -V 2>&1 |grep Solaris; then
-      # Use Solaris specific linker wrapper
-      ld="$out/bin/ld-solaris"
-    fi
-    # Can't use substitute() here, because replace may not have been
-    # built yet (in the bootstrap).
-    sed \
-        -e "s^@out@^$out^g" \
-        -e "s^@shell@^$shell^g" \
-        -e "s^@gcc@^$gcc^g" \
-        -e "s^@gccProg@^$gccProg^g" \
-        -e "s^@gnatProg@^$gnatProg^g" \
-        -e "s^@gnatlinkProg@^$gnatlinkProg^g" \
-        -e "s^@binutils@^$binutils^g" \
-        -e "s^@coreutils@^$coreutils^g" \
-        -e "s^@libc@^$libc^g" \
-        -e "s^@ld@^$ld^g" \
-        < "$src" > "$dst" 
-}
-
-
-# Make wrapper scripts around gcc, g++, and gfortran.  Also make symlinks
-# cc, c++, and f77.
-mkGccWrapper() {
-    local dst=$1
-    local src=$2
-
-    if ! test -f "$src"; then
-        echo "$src does not exist (skipping)"
-        return 1
-    fi
-
-    gccProg="$src"
-    doSubstitute "$gccWrapper" "$dst"
-    chmod +x "$dst"
-}
-
-mkGnatWrapper() {
-    local dst=$1
-    local src=$2
-
-    if ! test -f "$src"; then
-        echo "$src does not exist (skipping)"
-        return 1
-    fi
-
-    gnatProg="$src"
-    doSubstitute "$gnatWrapper" "$dst"
-    chmod +x "$dst"
-}
-
-mkGnatLinkWrapper() {
-    local dst=$1
-    local src=$2
-
-    if ! test -f "$src"; then
-        echo "$src does not exist (skipping)"
-        return 1
-    fi
-
-    gnatlinkProg="$src"
-    doSubstitute "$gnatlinkWrapper" "$dst"
-    chmod +x "$dst"
-}
-
-if mkGccWrapper $out/bin/gcc $gccPath/gcc
-then
-    ln -sv gcc $out/bin/cc
-fi
-
-if mkGccWrapper $out/bin/g++ $gccPath/g++
-then
-    ln -sv g++ $out/bin/c++
-fi
-
-mkGccWrapper $out/bin/cpp $gccPath/cpp || true
-
-if mkGccWrapper $out/bin/gfortran $gccPath/gfortran
-then
-    ln -sv gfortran $out/bin/g77
-    ln -sv gfortran $out/bin/f77
-fi
-
-mkGccWrapper $out/bin/gcj $gccPath/gcj || true
-
-mkGccWrapper $out/bin/gccgo $gccPath/gccgo || true
-
-mkGccWrapper $out/bin/gnatgcc $gccPath/gnatgcc || true
-mkGnatWrapper $out/bin/gnatmake $gccPath/gnatmake || true
-mkGnatWrapper $out/bin/gnatbind $gccPath/gnatbind || true
-mkGnatLinkWrapper $out/bin/gnatlink $gccPath/gnatlink || true
-
-if [ -f $gccPath/ghdl ]; then
-    ln -sf $gccPath/ghdl $out/bin/ghdl
-fi
-
-
-# Create a symlink to as (the assembler).  This is useful when a
-# gcc-wrapper is installed in a user environment, as it ensures that
-# the right assembler is called.
-ln -s $ldPath/as $out/bin/as
-
-
-# Make a wrapper around the linker.
-doSubstitute "$ldWrapper" "$out/bin/ld"
-chmod +x "$out/bin/ld"
-
-# Copy solaris ld wrapper if needed
-if $ldPath/ld -V 2>&1 |grep Solaris; then
-  # Use Solaris specific linker wrapper
-  sed -e "s^@ld@^$ldPath/ld^g" < "$ldSolarisWrapper" > "$out/bin/ld-solaris"
-  chmod +x "$out/bin/ld-solaris"
-fi
-
-
-# Emit a setup hook.  Also store the path to the original GCC and
-# Glibc.
-test -n "$gcc" && echo $gcc > $out/nix-support/orig-gcc
-test -n "$libc" && echo $libc > $out/nix-support/orig-libc
-
-doSubstitute "$addFlags" "$out/nix-support/add-flags.sh"
-
-doSubstitute "$setupHook" "$out/nix-support/setup-hook"
-
-cp -p $utils $out/nix-support/utils.sh
-
-
-# Propagate the wrapped gcc so that if you install the wrapper, you get
-# tools like gcov, the manpages, etc. as well (including for binutils
-# and Glibc).
-if test -z "$nativeTools"; then
-    echo $gcc $binutils $libc > $out/nix-support/propagated-user-env-packages
-fi

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

@@ -1,28 +1,29 @@
-# The Nix `gcc' stdenv.mkDerivation is not directly usable, since it doesn't
+# The Nixpkgs GCC is not directly usable, since it doesn't know where
-# know where the C library and standard header files are.  Therefore
+# the C library and standard header files are. Therefore the compiler
-# the compiler produced by that package cannot be installed directly
+# produced by that package cannot be installed directly in a user
-# in a user environment and used from the command line.  This
+# environment and used from the command line. So we use a wrapper
-# stdenv.mkDerivation provides a wrapper that sets up the right environment
+# script that sets up the right environment variables so that the
-# variables so that the compiler and the linker just "work".
+# compiler and the linker just "work".
 
 { name ? "", stdenv, nativeTools, nativeLibc, nativePrefix ? ""
-, gcc ? null, libc ? null, binutils ? null, coreutils ? null, shell ? ""
+, gcc ? null, libc ? null, binutils ? null, coreutils ? null, shell ? stdenv.shell
 , zlib ? null
 }:
 
+with stdenv.lib;
+
 assert nativeTools -> nativePrefix != "";
 assert !nativeTools -> gcc != null && binutils != null && coreutils != null;
 assert !nativeLibc -> libc != null;
 
-# For ghdl (the vhdl language provider to gcc) we need zlib in the wrapper
+# For ghdl (the vhdl language provider to gcc) we need zlib in the wrapper.
-assert (gcc != null && gcc ? langVhdl && gcc.langVhdl) -> zlib != null;
+assert gcc.langVhdl or false -> zlib != null;
 
 let
 
   gccVersion = (builtins.parseDrvName gcc.name).version;
   gccName = (builtins.parseDrvName gcc.name).name;
 
-  langGo = if nativeTools then false else gcc ? langGo && gcc.langGo;
 in
 
 stdenv.mkDerivation {
@@ -30,31 +31,175 @@ stdenv.mkDerivation {
     (if name != "" then name else gccName + "-wrapper") +
     (if gcc != null && gccVersion != "" then "-" + gccVersion else "");
 
-  builder = ./builder.sh;
+  preferLocalBuild = true;
-  setupHook = ./setup-hook.sh;
-  gccWrapper = ./gcc-wrapper.sh;
-  gnatWrapper = ./gnat-wrapper.sh;
-  gnatlinkWrapper = ./gnatlink-wrapper.sh;
-  ldWrapper = ./ld-wrapper.sh;
-  ldSolarisWrapper = ./ld-solaris-wrapper.sh;
-  utils = ./utils.sh;
-  addFlags = ./add-flags;
 
-  inherit nativeTools nativeLibc nativePrefix gcc;
+  inherit gcc shell;
   libc = if nativeLibc then null else libc;
   binutils = if nativeTools then null else binutils;
-  # The wrapper scripts use 'cat', so we may need coreutils
+  # The wrapper scripts use 'cat', so we may need coreutils.
   coreutils = if nativeTools then null else coreutils;
 
-  langC = if nativeTools then true else gcc.langC;
+  passthru = { inherit nativeTools nativeLibc nativePrefix; };
-  langCC = if nativeTools then true else gcc.langCC;
+
-  langFortran = if nativeTools then false else gcc ? langFortran;
+  buildCommand =
-  langAda = if nativeTools then false else gcc ? langAda && gcc.langAda;
+    ''
-  langVhdl = if nativeTools then false else gcc ? langVhdl && gcc.langVhdl;
+      mkdir -p $out/bin $out/nix-support
-  zlib = if gcc != null && gcc ? langVhdl then zlib else null;
+
-  shell = if shell == "" then stdenv.shell else
+      wrap() {
-    if builtins.isAttrs shell then (shell + shell.shellPath)
+        local dst="$1"
-    else shell;
+        local wrapper="$2"
+        export prog="$3"
+        substituteAll "$wrapper" "$out/bin/$dst"
+        chmod +x "$out/bin/$dst"
+      }
+    ''
+
+    + optionalString (!nativeLibc) ''
+      dynamicLinker="$libc/lib/$dynamicLinker"
+      echo $dynamicLinker > $out/nix-support/dynamic-linker
+
+      if [ -e $libc/lib/32/ld-linux.so.2 ]; then
+        echo $libc/lib/32/ld-linux.so.2 > $out/nix-support/dynamic-linker-m32
+      fi
+
+      # The "-B$libc/lib/" flag is a quick hack to force gcc to link
+      # against the crt1.o from our own glibc, rather than the one in
+      # /usr/lib.  (This is only an issue when using an `impure'
+      # compiler/linker, i.e., one that searches /usr/lib and so on.)
+      #
+      # Unfortunately, setting -B appears to override the default search
+      # path. Thus, the gcc-specific "../includes-fixed" directory is
+      # now longer searched and glibc's <limits.h> header fails to
+      # compile, because it uses "#include_next <limits.h>" to find the
+      # limits.h file in ../includes-fixed. To remedy the problem,
+      # another -idirafter is necessary to add that directory again.
+      echo "-B$libc/lib/ -idirafter $libc/include -idirafter $gcc/lib/gcc/*/*/include-fixed" > $out/nix-support/libc-cflags
+
+      echo "-L$libc/lib" > $out/nix-support/libc-ldflags
+
+      # 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).
+      echo "-dynamic-linker" $dynamicLinker > $out/nix-support/libc-ldflags-before
+
+      echo $libc > $out/nix-support/orig-libc
+    ''
+
+    + (if nativeTools then ''
+      gccPath="${nativePrefix}/bin"
+      ldPath="${nativePrefix}/bin"
+    '' else ''
+      echo $gcc > $out/nix-support/orig-gcc
+
+      # GCC shows $gcc/lib in `gcc -print-search-dirs', but not
+      # $gcc/lib64 (even though it does actually search there...)..
+      # This confuses libtool.  So add it to the compiler tool search
+      # path explicitly.
+      if [ -e "$gcc/lib64" -a ! -L "$gcc/lib64" ]; then
+        gccLDFlags+=" -L$gcc/lib64"
+        gccCFlags+=" -B$gcc/lib64"
+      fi
+      gccLDFlags+=" -L$gcc/lib"
+
+      ${optionalString gcc.langVhdl or false ''
+        gccLDFlags+=" -L${zlib}/lib"
+      ''}
+
+      # Find the gcc libraries path (may work only without multilib).
+      ${optionalString gcc.langAda or false ''
+        basePath=`echo $gcc/lib/*/*/*`
+        gccCFlags+=" -B$basePath -I$basePath/adainclude"
+        gnatCFlags="-aI$basePath/adainclude -aO$basePath/adalib"
+        echo "$gnatCFlags" > $out/nix-support/gnat-cflags
+      ''}
+
+      echo "$gccLDFlags" > $out/nix-support/gcc-ldflags
+      echo "$gccCFlags" > $out/nix-support/gcc-cflags
+
+      gccPath="$gcc/bin"
+      ldPath="$binutils/bin"
+      ld="$ldPath/ld"
+
+      # Propagate the wrapped gcc so that if you install the wrapper,
+      # you get tools like gcov, the manpages, etc. as well (including
+      # for binutils and Glibc).
+      echo $gcc $binutils $libc > $out/nix-support/propagated-user-env-packages
+    ''
+
+    + optionalString (stdenv.isSunOS && nativePrefix != "") ''
+      # Solaris needs an additional ld wrapper.
+      ldPath="${nativePrefix}/bin"
+      ld="$out/bin/ld-solaris"
+      wrap ld-solaris ${./ld-solaris-wrapper.sh}
+    '')
+
+    + ''
+      # Create a symlink to as (the assembler).  This is useful when a
+      # gcc-wrapper is installed in a user environment, as it ensures that
+      # the right assembler is called.
+      if [ -e $ldPath/as ]; then
+        ln -s $ldPath/as $out/bin/as
+      fi
+
+      wrap ld ${./ld-wrapper.sh} $ld
+
+      if [ -e $gccPath/gcc ]; then
+        wrap gcc ${./gcc-wrapper.sh} $gccPath/gcc
+        ln -s gcc $out/bin/cc
+      fi
+
+      if [ -e $gccPath/g++ ]; then
+        wrap g++ ${./gcc-wrapper.sh} $gccPath/g++
+        ln -s g++ $out/bin/c++
+      fi
+
+      if [ -e $gccPath/cpp ]; then
+        wrap cpp ${./gcc-wrapper.sh} $gccPath/cpp
+      fi
+    ''
+
+    + optionalString gcc.langFortran or false ''
+      wrap gfortran ${./gcc-wrapper.sh} $gccPath/gfortran
+      ln -sv gfortran $out/bin/g77
+      ln -sv gfortran $out/bin/f77
+    ''
+
+    + optionalString gcc.langJava or false ''
+      wrap gcj ${./gcc-wrapper.sh} $gccPath/gcj
+    ''
+
+    + optionalString gcc.langGo or false ''
+      wrap gccgo ${./gcc-wrapper.sh} $gccPath/gccgo
+    ''
+
+    + optionalString gcc.langAda or false ''
+      wrap gnatgcc ${./gcc-wrapper.sh} $gccPath/gnatgcc
+      wrap gnatmake ${./gnat-wrapper.sh} $gccPath/gnatmake
+      wrap gnatbind ${./gnat-wrapper.sh} $gccPath/gnatbind
+      wrap gnatlink ${./gnatlink-wrapper.sh} $gccPath/gnatlink
+    ''
+
+    + optionalString gcc.langVhdl or false ''
+      ln -s $gccPath/ghdl $out/bin/ghdl
+    ''
+
+    + ''
+      substituteAll ${./setup-hook.sh} $out/nix-support/setup-hook
+      substituteAll ${./add-flags} $out/nix-support/add-flags.sh
+      cp -p ${./utils.sh} $out/nix-support/utils.sh
+    '';
+
+  # The dynamic linker has different names on different Linux platforms.
+  dynamicLinker =
+    if !nativeLibc then
+      (if stdenv.system == "i686-linux" then "ld-linux.so.2" else
+       if stdenv.system == "x86_64-linux" then "ld-linux-x86-64.so.2" else
+       # ARM with a wildcard, which can be "" or "-armhf".
+       if stdenv.isArm then "ld-linux*.so.3" else
+       if stdenv.system == "powerpc-linux" then "ld.so.1" else
+       if stdenv.system == "mips64el-linux" then "ld.so.1" else
+       abort "Don't know the name of the dynamic linker for this platform.")
+    else "";
 
   crossAttrs = {
     shell = shell.crossDrv + shell.crossDrv.shellPath;
@@ -73,8 +218,6 @@ stdenv.mkDerivation {
        abort "don't know the name of the dynamic linker for this platform");
   };
 
-  preferLocalBuild = true;
-
   meta =
     let gcc_ = if gcc != null then gcc else {}; in
     (if gcc_ ? meta then removeAttrs gcc.meta ["priority"] else {}) //
@@ -82,16 +225,4 @@ stdenv.mkDerivation {
         stdenv.lib.attrByPath ["meta" "description"] "System C compiler" gcc_
         + " (wrapper script)";
     };
-
-  # The dynamic linker has different names on different Linux platforms.
-  dynamicLinker =
-    if !nativeLibc then
-      (if stdenv.system == "i686-linux" then "ld-linux.so.2" else
-       if stdenv.system == "x86_64-linux" then "ld-linux-x86-64.so.2" else
-       # ARM with a wildcard, which can be "" or "-armhf".
-       if stdenv.isArm then "ld-linux*.so.3" else
-       if stdenv.system == "powerpc-linux" then "ld.so.1" else
-       if stdenv.system == "mips64el-linux" then "ld.so.1" else
-       abort "don't know the name of the dynamic linker for this platform")
-    else "";
 }

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

@@ -125,15 +125,15 @@ fi
 
 # Optionally print debug info.
 if test "$NIX_DEBUG" = "1"; then
-  echo "original flags to @gccProg@:" >&2
+  echo "original flags to @prog@:" >&2
   for i in "${params[@]}"; do
       echo "  $i" >&2
   done
-  echo "extraBefore flags to @gccProg@:" >&2
+  echo "extraBefore flags to @prog@:" >&2
   for i in ${extraBefore[@]}; do
       echo "  $i" >&2
   done
-  echo "extraAfter flags to @gccProg@:" >&2
+  echo "extraAfter flags to @prog@:" >&2
   for i in ${extraAfter[@]}; do
       echo "  $i" >&2
   done
@@ -143,4 +143,4 @@ if test -n "$NIX_GCC_WRAPPER_EXEC_HOOK"; then
     source "$NIX_GCC_WRAPPER_EXEC_HOOK"
 fi
 
-exec @gccProg@ ${extraBefore[@]} "${params[@]}" "${extraAfter[@]}"
+exec @prog@ ${extraBefore[@]} "${params[@]}" "${extraAfter[@]}"

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

@@ -82,15 +82,15 @@ fi
 
 # Optionally print debug info.
 if test "$NIX_DEBUG" = "1"; then
-  echo "original flags to @gnatProg@:" >&2
+  echo "original flags to @prog@:" >&2
   for i in "${params[@]}"; do
       echo "  $i" >&2
   done
-  echo "extraBefore flags to @gnatProg@:" >&2
+  echo "extraBefore flags to @prog@:" >&2
   for i in ${extraBefore[@]}; do
       echo "  $i" >&2
   done
-  echo "extraAfter flags to @gnatProg@:" >&2
+  echo "extraAfter flags to @prog@:" >&2
   for i in ${extraAfter[@]}; do
       echo "  $i" >&2
   done
@@ -100,4 +100,4 @@ if test -n "$NIX_GNAT_WRAPPER_EXEC_HOOK"; then
     source "$NIX_GNAT_WRAPPER_EXEC_HOOK"
 fi
 
-exec @gnatProg@ ${extraBefore[@]} "${params[@]}" ${extraAfter[@]}
+exec @prog@ ${extraBefore[@]} "${params[@]}" ${extraAfter[@]}

pkgs/build-support/gcc-wrapper/gnatlink-wrapper.sh

@@ -12,15 +12,15 @@ extraBefore=()
 
 # Optionally print debug info.
 if test "$NIX_DEBUG" = "1"; then
-  echo "original flags to @gnatlinkProg@:" >&2
+  echo "original flags to @prog@:" >&2
   for i in "$@"; do
       echo "  $i" >&2
   done
-  echo "extraBefore flags to @gnatlinkProg@:" >&2
+  echo "extraBefore flags to @prog@:" >&2
   for i in ${extraBefore[@]}; do
       echo "  $i" >&2
   done
-  echo "extraAfter flags to @gnatlinkProg@:" >&2
+  echo "extraAfter flags to @prog@:" >&2
   for i in ${extraAfter[@]}; do
       echo "  $i" >&2
   done
@@ -30,4 +30,4 @@ if test -n "$NIX_GNAT_WRAPPER_EXEC_HOOK"; then
     source "$NIX_GNAT_WRAPPER_EXEC_HOOK"
 fi
 
-exec @gnatlinkProg@ ${extraBefore[@]} "$@" ${extraAfter[@]}
+exec @prog@ ${extraBefore[@]} "$@" ${extraAfter[@]}

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

@@ -6,7 +6,7 @@ set -u
 # 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.
-cmd="@ld@ -z ignore"
+cmd="@prog@ -z ignore"
 
 args=("$@");
 

pkgs/build-support/gcc-wrapper/ld-wrapper.sh

@@ -149,11 +149,11 @@ fi
 
 # Optionally print debug info.
 if test "$NIX_DEBUG" = "1"; then
-  echo "original flags to @ld@:" >&2
+  echo "original flags to @prog@:" >&2
   for i in "${params[@]}"; do
       echo "  $i" >&2
   done
-  echo "extra flags to @ld@:" >&2
+  echo "extra flags to @prog@:" >&2
   for i in ${extra[@]}; do
       echo "  $i" >&2
   done
@@ -163,4 +163,4 @@ if test -n "$NIX_LD_WRAPPER_EXEC_HOOK"; then
     source "$NIX_LD_WRAPPER_EXEC_HOOK"
 fi
 
-exec @ld@ ${extraBefore[@]} "${params[@]}" ${extra[@]}
+exec @prog@ ${extraBefore[@]} "${params[@]}" ${extra[@]}

pkgs/top-level/all-packages.nix

@@ -2784,7 +2784,6 @@ let
     stdenv = clangStdenv;
     libc = glibc;
     binutils = binutils;
-    shell = bash;
     inherit coreutils zlib;
     extraPackages = [ libcxx ];
     nativeTools = false;
@@ -3661,12 +3660,11 @@ let
   win32hello = callPackage ../development/compilers/visual-c++/test { };
 
   wrapGCCWith = gccWrapper: glibc: baseGCC: gccWrapper {
-    nativeTools = stdenv ? gcc && stdenv.gcc.nativeTools;
+    nativeTools = stdenv.gcc.nativeTools or false;
-    nativeLibc = stdenv ? gcc && stdenv.gcc.nativeLibc;
+    nativeLibc = stdenv.gcc.nativeLibc or false;
-    nativePrefix = if stdenv ? gcc then stdenv.gcc.nativePrefix else "";
+    nativePrefix = stdenv.gcc.nativePrefix or "";
     gcc = baseGCC;
     libc = glibc;
-    shell = bash;
     inherit stdenv binutils coreutils zlib;
   };
 
@@ -3676,7 +3674,6 @@ let
     nativePrefix = stdenv.gcc.nativePrefix or "";
     clang = baseClang;
     libc = glibc;
-    shell = bash;
     binutils = stdenv.gcc.binutils;
     inherit stdenv coreutils zlib;
   };