From 3e0a3487287743dfe8020533bf7690e124a1748a Mon Sep 17 00:00:00 2001 From: Eelco Dolstra Date: Fri, 10 Oct 2014 13:49:26 +0200 Subject: [PATCH] gcc-wrapper: Get rid of builder.sh + cleanup --- pkgs/build-support/gcc-wrapper/builder.sh | 214 ----------------- pkgs/build-support/gcc-wrapper/default.nix | 219 ++++++++++++++---- pkgs/build-support/gcc-wrapper/gcc-wrapper.sh | 8 +- .../build-support/gcc-wrapper/gnat-wrapper.sh | 8 +- .../gcc-wrapper/gnatlink-wrapper.sh | 8 +- .../gcc-wrapper/ld-solaris-wrapper.sh | 2 +- pkgs/build-support/gcc-wrapper/ld-wrapper.sh | 6 +- pkgs/top-level/all-packages.nix | 9 +- 8 files changed, 194 insertions(+), 280 deletions(-) delete mode 100644 pkgs/build-support/gcc-wrapper/builder.sh diff --git a/pkgs/build-support/gcc-wrapper/builder.sh b/pkgs/build-support/gcc-wrapper/builder.sh deleted file mode 100644 index c79680712ee7..000000000000 --- a/pkgs/build-support/gcc-wrapper/builder.sh +++ /dev/null @@ -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 header fails to - # compile, because it uses "#include_next " 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 diff --git a/pkgs/build-support/gcc-wrapper/default.nix b/pkgs/build-support/gcc-wrapper/default.nix index 8e8b0b909454..5b80c92acbfc 100644 --- a/pkgs/build-support/gcc-wrapper/default.nix +++ b/pkgs/build-support/gcc-wrapper/default.nix @@ -1,28 +1,29 @@ -# The Nix `gcc' stdenv.mkDerivation 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. This -# stdenv.mkDerivation provides a wrapper that sets up the right environment -# variables so that the compiler and the linker just "work". +# The Nixpkgs GCC 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, 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 -assert (gcc != null && gcc ? langVhdl && gcc.langVhdl) -> zlib != null; +# For ghdl (the vhdl language provider to gcc) we need zlib in the wrapper. +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; - 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; + preferLocalBuild = true; - 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; - langCC = if nativeTools then true else gcc.langCC; - langFortran = if nativeTools then false else gcc ? langFortran; - langAda = if nativeTools then false else gcc ? langAda && gcc.langAda; - langVhdl = if nativeTools then false else gcc ? langVhdl && gcc.langVhdl; - zlib = if gcc != null && gcc ? langVhdl then zlib else null; - shell = if shell == "" then stdenv.shell else - if builtins.isAttrs shell then (shell + shell.shellPath) - else shell; + passthru = { inherit nativeTools nativeLibc nativePrefix; }; + + buildCommand = + '' + mkdir -p $out/bin $out/nix-support + + wrap() { + local dst="$1" + 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 header fails to + # compile, because it uses "#include_next " 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 ""; } diff --git a/pkgs/build-support/gcc-wrapper/gcc-wrapper.sh b/pkgs/build-support/gcc-wrapper/gcc-wrapper.sh index d01ce54fd969..f515fafdac0a 100644 --- a/pkgs/build-support/gcc-wrapper/gcc-wrapper.sh +++ b/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[@]}" diff --git a/pkgs/build-support/gcc-wrapper/gnat-wrapper.sh b/pkgs/build-support/gcc-wrapper/gnat-wrapper.sh index 4404194ff1bf..3c2f1d034744 100644 --- a/pkgs/build-support/gcc-wrapper/gnat-wrapper.sh +++ b/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[@]} diff --git a/pkgs/build-support/gcc-wrapper/gnatlink-wrapper.sh b/pkgs/build-support/gcc-wrapper/gnatlink-wrapper.sh index d8e4b5254bfc..cd7768c85a39 100644 --- a/pkgs/build-support/gcc-wrapper/gnatlink-wrapper.sh +++ b/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[@]} diff --git a/pkgs/build-support/gcc-wrapper/ld-solaris-wrapper.sh b/pkgs/build-support/gcc-wrapper/ld-solaris-wrapper.sh index 5a7b92b5ad7d..9216ea3198dd 100644 --- a/pkgs/build-support/gcc-wrapper/ld-solaris-wrapper.sh +++ b/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=("$@"); diff --git a/pkgs/build-support/gcc-wrapper/ld-wrapper.sh b/pkgs/build-support/gcc-wrapper/ld-wrapper.sh index 822c4a03a218..df00dcdb222a 100644 --- a/pkgs/build-support/gcc-wrapper/ld-wrapper.sh +++ b/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[@]} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 66fc0d8df6f7..43985bd6a6b2 100644 --- a/pkgs/top-level/all-packages.nix +++ b/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; - nativeLibc = stdenv ? gcc && stdenv.gcc.nativeLibc; - nativePrefix = if stdenv ? gcc then stdenv.gcc.nativePrefix else ""; + nativeTools = stdenv.gcc.nativeTools or false; + nativeLibc = stdenv.gcc.nativeLibc or false; + 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; };