commit 4a2340ff6bd0474d9a3e933f28b8568c59019b82 · pyrox.dev/nixpkgs

+43 -12

doc/stdenv.xml

···

       1358
        
       <variablelist>

     

       1359
        
       

     

       1360
        
         <varlistentry>

     

       1361
       -
           <term>CC Wrapper</term>

     

       1362
        
           <listitem>

     

       1363
        
             <para>

     

       1364
       -
               CC Wrapper wraps a C toolchain for a bunch of miscellaneous purposes.

     

       1365
       -
               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.

     

       1366
       -
               Packages typically depend on only CC Wrapper, instead of those 3 inputs directly.

     

       0
        
       
     

       0
        
       
     

       1367
        
             </para>

     

       1368
        
             <para>

     

       1369
       -
               Dependency finding is undoubtedly the main task of CC wrapper.

     

       0
        
       
     

       0
        
       
     

       1370
        
               It is currently accomplished by collecting directories of host-platform dependencies (i.e. <varname>buildInputs</varname> and <varname>nativeBuildInputs</varname>) in environment variables.

     

       1371
       -
               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>.

     

       1372
       -
               The setup hook itself contains some lengthy comments describing the exact convoluted mechanism by which this is accomplished.

     

       0
        
       
     

       0
        
       
     

       1373
        
             </para>

     

       1374
        
             <para>

     

       1375
        
               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.

     

       1376
       -
               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.

     

       1377
        
               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.

     

       1378
       -
               Secondly, this helps packages not get confused when cross-compiling, in which case multiple CC wrappers may be simultaneous in use (targeting different platforms).

     

       1379
       -
               <envar>BUILD_</envar>- and <envar>TARGET_</envar>-prefixed versions of the normal environment variable are defined for the additional CC Wrappers, properly disambiguating them.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1380
        
             </para>

     

       1381
        
             <para>

     

       1382
       -
               A problem with this final task is that CC Wrapper is honest and defines <envar>LD</envar> as <command>ld</command>.

     

       1383
        
               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.

     

       1384
       -
               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.

     

       1385
        
               The workaround is to define, just for the problematic package, <envar>LD</envar> as the C compiler.

     

       1386
        
               A good way to do this would be <command>preConfigure = "LD=$CC"</command>.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1387
        
             </para>

     

       1388
        
           </listitem>

     

       1389
        
         </varlistentry>

···

       1358
        
       <variablelist>

     

       1359
        
       

     

       1360
        
         <varlistentry>

     

       1361
       +
           <term>Bintools Wrapper</term>

     

       1362
        
           <listitem>

     

       1363
        
             <para>

     

       1364
       +
               Bintools Wrapper wraps the binary utilities for a bunch of miscellaneous purposes.

     

       1365
       +
               These are GNU Binutils when targetting Linux, and a mix of cctools and GNU binutils for Darwin.

     

       1366
       +
               [The "Bintools" name is supposed to be a compromise between "Binutils" and "cctools" not denoting any specific implementation.]

     

       1367
       +
               Specifically, the underlying bintools package, 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 Bintools Wrapper.

     

       1368
       +
               Packages typically depend on CC Wrapper, which in turn (at run time) depends on Bintools Wrapper.

     

       1369
        
             </para>

     

       1370
        
             <para>

     

       1371
       +
               Bintools Wrapper was only just recently split off from CC Wrapper, so the division of labor is still being worked out.

     

       1372
       +
               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).

     

       1373
       +
               Dependency finding however is a task both wrappers will continue to need to share, and probably the most important to understand.

     

       1374
        
               It is currently accomplished by collecting directories of host-platform dependencies (i.e. <varname>buildInputs</varname> and <varname>nativeBuildInputs</varname>) in environment variables.

     

       1375
       +
               Bintools Wrapper's setup hook causes any <filename>lib</filename> and <filename>lib64</filename> subdirectories to be added to <envar>NIX_LDFLAGS</envar>.

     

       1376
       +
               Since CC Wrapper and Bintools Wrapper use the same strategy, most of the Bintools Wrapper code is sparsely commented and refers to CC Wrapper.

     

       1377
       +
               But CC Wrapper's code, by contrast, has quite lengthy comments.

     

       1378
       +
               Bintools Wrapper merely cites those, rather than repeating them, to avoid falling out of sync.

     

       1379
        
             </para>

     

       1380
        
             <para>

     

       1381
        
               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.

     

       1382
       +
               They are defined to just be the base name of the tools, under the assumption that Bintools Wrapper's binaries will be on the path.

     

       1383
        
               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.

     

       1384
       +
               Secondly, this helps packages not get confused when cross-compiling, in which case multiple Bintools Wrappers may simultaneously be in use.

     

       1385
       +
               <footnote><para>

     

       1386
       +
                 Each wrapper targets a single platform, so if binaries for multiple platforms are needed, the underlying binaries must be wrapped multiple times.

     

       1387
       +
                 As this is a property of the wrapper itself, the multiple wrappings are needed whether or not the same underlying binaries can target multiple platforms.

     

       1388
       +
               </para></footnote>

     

       1389
       +
               <envar>BUILD_</envar>- and <envar>TARGET_</envar>-prefixed versions of the normal environment variable are defined for the additional Bintools Wrappers, properly disambiguating them.

     

       1390
        
             </para>

     

       1391
        
             <para>

     

       1392
       +
               A problem with this final task is that Bintools Wrapper is honest and defines <envar>LD</envar> as <command>ld</command>.

     

       1393
        
               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.

     

       1394
       +
               This triple-threat means Bintools Wrapper will break those packages, as LD is already defined as the actual linker which the package won't override yet doesn't want to use.

     

       1395
        
               The workaround is to define, just for the problematic package, <envar>LD</envar> as the C compiler.

     

       1396
        
               A good way to do this would be <command>preConfigure = "LD=$CC"</command>.

     

       1397
       +
             </para>

     

       1398
       +
           </listitem>

     

       1399
       +
         </varlistentry>

     

       1400
       +
       

     

       1401
       +
         <varlistentry>

     

       1402
       +
           <term>CC Wrapper</term>

     

       1403
       +
           <listitem>

     

       1404
       +
             <para>

     

       1405
       +
               CC Wrapper wraps a C toolchain for a bunch of miscellaneous purposes.

     

       1406
       +
               Specifically, a C compiler (GCC or Clang), wrapped binary tools, 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 CC Wrapper.

     

       1407
       +
               Packages typically depend on CC Wrapper, which in turn (at run time) depends on Bintools Wrapper.

     

       1408
       +
             </para>

     

       1409
       +
             <para>

     

       1410
       +
               Dependency finding is undoubtedly the main task of CC Wrapper.

     

       1411
       +
               This works just like Bintools Wrapper, except that any <filename>include</filename> subdirectory of any relevant dependency is added to <envar>NIX_CFLAGS_COMPILE</envar>.

     

       1412
       +
               The setup hook itself contains some lengthy comments describing the exact convoluted mechanism by which this is accomplished.

     

       1413
       +
             </para>

     

       1414
       +
             <para>

     

       1415
       +
               CC Wrapper also like Bintools Wrapper defines standard environment variables with the names of the tools it wraps, for the same reasons described above.

     

       1416
       +
               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>).

     

       1417
       +
               This helps lousy build systems that inspect on the name of the compiler rather than run it.

     

       1418
        
             </para>

     

       1419
        
           </listitem>

     

       1420
        
         </varlistentry>

+9 -2

pkgs/applications/video/mpv/default.nix

···

       1
       -
       { stdenv, fetchurl, fetchFromGitHub, makeWrapper

     

       2
        
       , docutils, perl, pkgconfig, python3, which, ffmpeg

     

       3
        
       , freefont_ttf, freetype, libass, libpthreadstubs

     

       4
        
       , lua, lua5_sockets, libuchardet, libiconv ? null, darwin

     
···

       90
        
           sha256 = "0746kmsg69675y5c70vn8imcr9d1zpjz97f27xr1vx00yjpd518v";

     

       91
        
         };

     

       92
        
       

     

       93
       -
         patchPhase = ''

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       94
        
           patchShebangs ./TOOLS/

     

       95
        
         '';

     

       96

···

       1
       +
       { stdenv, fetchurl, fetchFromGitHub, fetchpatch, makeWrapper

     

       2
        
       , docutils, perl, pkgconfig, python3, which, ffmpeg

     

       3
        
       , freefont_ttf, freetype, libass, libpthreadstubs

     

       4
        
       , lua, lua5_sockets, libuchardet, libiconv ? null, darwin

     
···

       90
        
           sha256 = "0746kmsg69675y5c70vn8imcr9d1zpjz97f27xr1vx00yjpd518v";

     

       91
        
         };

     

       92
        
       

     

       93
       +
         patches = [

     

       94
       +
           (fetchpatch {

     

       95
       +
             url = "https://github.com/mpv-player/mpv/commit/2ecf240b1cd20875991a5b18efafbe799864ff7f.patch";

     

       96
       +
             sha256 = "1sr0770rvhsgz8d7ysr9qqp4g9gwdhgj8g3rgnz90wl49lgrykhb";

     

       97
       +
           })

     

       98
       +
         ];

     

       99
       +
       

     

       100
       +
         postPatch = ''

     

       101
        
           patchShebangs ./TOOLS/

     

       102
        
         '';

     

       103

+40

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

···

       1
       +
       # See cc-wrapper for comments.

     

       2
       +
       var_templates_list=(

     

       3
       +
           NIX+IGNORE_LD_THROUGH_GCC

     

       4
       +
           NIX+LDFLAGS

     

       5
       +
           NIX+LDFLAGS_BEFORE

     

       6
       +
           NIX+LDFLAGS_AFTER

     

       7
       +
           NIX+LDFLAGS_HARDEN

     

       8
       +
       )

     

       9
       +
       var_templates_bool=(

     

       10
       +
           NIX+SET_BUILD_ID

     

       11
       +
           NIX+DONT_SET_RPATH

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       declare -a role_infixes=()

     

       15
       +
       if [ "${NIX_BINTOOLS_WRAPPER_@infixSalt@_TARGET_BUILD:-}" ]; then

     

       16
       +
           role_infixes+=(_BUILD_)

     

       17
       +
       fi

     

       18
       +
       if [ "${NIX_BINTOOLS_WRAPPER_@infixSalt@_TARGET_HOST:-}" ]; then

     

       19
       +
           role_infixes+=(_)

     

       20
       +
       fi

     

       21
       +
       if [ "${NIX_BINTOOLS_WRAPPER_@infixSalt@_TARGET_TARGET:-}" ]; then

     

       22
       +
           role_infixes+=(_TARGET_)

     

       23
       +
       fi

     

       24
       +
       

     

       25
       +
       for var in "${var_templates_list[@]}"; do

     

       26
       +
           mangleVarList "$var" "${role_infixes[@]}"

     

       27
       +
       done

     

       28
       +
       for var in "${var_templates_bool[@]}"; do

     

       29
       +
           mangleVarBool "$var" "${role_infixes[@]}"

     

       30
       +
       done

     

       31
       +
       

     

       32
       +
       if [ -e @out@/nix-support/libc-ldflags ]; then

     

       33
       +
           NIX_@infixSalt@_LDFLAGS+=" $(< @out@/nix-support/libc-ldflags)"

     

       34
       +
       fi

     

       35
       +
       

     

       36
       +
       if [ -e @out@/nix-support/libc-ldflags-before ]; then

     

       37
       +
           NIX_@infixSalt@_LDFLAGS_BEFORE="$(< @out@/nix-support/libc-ldflags-before) $NIX_@infixSalt@_LDFLAGS_BEFORE"

     

       38
       +
       fi

     

       39
       +
       

     

       40
       +
       export NIX_BINTOOLS_WRAPPER_@infixSalt@_FLAGS_SET=1

+53

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

···

       1
       +
       hardeningFlags=(relro bindnow)

     

       2
       +
       # Intentionally word-split in case 'hardeningEnable' is defined in

     

       3
       +
       # Nix. Also, our bootstrap tools version of bash is old enough that

     

       4
       +
       # undefined arrays trip `set -u`.

     

       5
       +
       if [[ -v hardeningEnable[@] ]]; then

     

       6
       +
         hardeningFlags+=(${hardeningEnable[@]})

     

       7
       +
       fi

     

       8
       +
       hardeningLDFlags=()

     

       9
       +
       

     

       10
       +
       declare -A hardeningDisableMap

     

       11
       +
       

     

       12
       +
       # Intentionally word-split in case 'hardeningDisable' is defined in Nix.

     

       13
       +
       for flag in ${hardeningDisable[@]:-IGNORED_KEY} @hardening_unsupported_flags@

     

       14
       +
       do

     

       15
       +
         hardeningDisableMap[$flag]=1

     

       16
       +
       done

     

       17
       +
       

     

       18
       +
       if (( "${NIX_DEBUG:-0}" >= 1 )); then

     

       19
       +
         printf 'HARDENING: disabled flags:' >&2

     

       20
       +
         (( "${#hardeningDisableMap[@]}" )) && printf ' %q' "${!hardeningDisableMap[@]}" >&2

     

       21
       +
         echo >&2

     

       22
       +
       fi

     

       23
       +
       

     

       24
       +
       if [[ -z "${hardeningDisableMap[all]:-}" ]]; then

     

       25
       +
         if (( "${NIX_DEBUG:-0}" >= 1 )); then

     

       26
       +
           echo 'HARDENING: Is active (not completely disabled with "all" flag)' >&2;

     

       27
       +
         fi

     

       28
       +
         for flag in "${hardeningFlags[@]}"

     

       29
       +
         do

     

       30
       +
           if [[ -z "${hardeningDisableMap[$flag]:-}" ]]; then

     

       31
       +
             case $flag in

     

       32
       +
               pie)

     

       33
       +
                 if [[ ! ("$*" =~ " -shared " || "$*" =~ " -static ") ]]; then

     

       34
       +
                   if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling LDFlags -pie >&2; fi

     

       35
       +
                   hardeningLDFlags+=('-pie')

     

       36
       +
                 fi

     

       37
       +
                 ;;

     

       38
       +
               relro)

     

       39
       +
                 if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling relro >&2; fi

     

       40
       +
                 hardeningLDFlags+=('-z' 'relro')

     

       41
       +
                 ;;

     

       42
       +
               bindnow)

     

       43
       +
                 if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling bindnow >&2; fi

     

       44
       +
                 hardeningLDFlags+=('-z' 'now')

     

       45
       +
                 ;;

     

       46
       +
               *)

     

       47
       +
                 # Ignore unsupported. Checked in Nix that at least *some*

     

       48
       +
                 # tool supports each flag.

     

       49
       +
                 ;;

     

       50
       +
             esac

     

       51
       +
           fi

     

       52
       +
         done

     

       53
       +
       fi

+292

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

···

       1
       +
       # The Nixpkgs CC is not directly usable, since it doesn't know where

     

       2
       +
       # the C library and standard header files are. Therefore the compiler

     

       3
       +
       # produced by that package cannot be installed directly in a user

     

       4
       +
       # environment and used from the command line. So we use a wrapper

     

       5
       +
       # script that sets up the right environment variables so that the

     

       6
       +
       # compiler and the linker just "work".

     

       7
       +
       

     

       8
       +
       { name ? "", stdenvNoCC, nativeTools, noLibc ? false, nativeLibc, nativePrefix ? ""

     

       9
       +
       , bintools ? null, libc ? null

     

       10
       +
       , coreutils ? null, shell ? stdenvNoCC.shell, gnugrep ? null

     

       11
       +
       , extraPackages ? [], extraBuildCommands ? ""

     

       12
       +
       , buildPackages ? {}

     

       13
       +
       , useMacosReexportHack ? false

     

       14
       +
       }:

     

       15
       +
       

     

       16
       +
       with stdenvNoCC.lib;

     

       17
       +
       

     

       18
       +
       assert nativeTools -> nativePrefix != "";

     

       19
       +
       assert !nativeTools ->

     

       20
       +
         bintools != null && coreutils != null && gnugrep != null;

     

       21
       +
       assert !(nativeLibc && noLibc);

     

       22
       +
       assert (noLibc || nativeLibc) == (libc == null);

     

       23
       +
       

     

       24
       +
       let

     

       25
       +
         stdenv = stdenvNoCC;

     

       26
       +
         inherit (stdenv) hostPlatform targetPlatform;

     

       27
       +
       

     

       28
       +
         # Prefix for binaries. Customarily ends with a dash separator.

     

       29
       +
         #

     

       30
       +
         # TODO(@Ericson2314) Make unconditional, or optional but always true by

     

       31
       +
         # default.

     

       32
       +
         targetPrefix = stdenv.lib.optionalString (targetPlatform != hostPlatform)

     

       33
       +
                                               (targetPlatform.config + "-");

     

       34
       +
       

     

       35
       +
         bintoolsVersion = (builtins.parseDrvName bintools.name).version;

     

       36
       +
         bintoolsName = (builtins.parseDrvName bintools.name).name;

     

       37
       +
       

     

       38
       +
         libc_bin = if libc == null then null else getBin libc;

     

       39
       +
         libc_dev = if libc == null then null else getDev libc;

     

       40
       +
         libc_lib = if libc == null then null else getLib libc;

     

       41
       +
         bintools_bin = if nativeTools then "" else getBin bintools;

     

       42
       +
         # The wrapper scripts use 'cat' and 'grep', so we may need coreutils.

     

       43
       +
         coreutils_bin = if nativeTools then "" else getBin coreutils;

     

       44
       +
       

     

       45
       +
         dashlessTarget = stdenv.lib.replaceStrings ["-"] ["_"] targetPlatform.config;

     

       46
       +
       

     

       47
       +
         # See description in cc-wrapper.

     

       48
       +
         infixSalt = dashlessTarget;

     

       49
       +
       

     

       50
       +
         # The dynamic linker has different names on different platforms. This is a

     

       51
       +
         # shell glob that ought to match it.

     

       52
       +
         dynamicLinker =

     

       53
       +
           /**/ if libc == null then null

     

       54
       +
           else if targetPlatform.system == "i686-linux"     then "${libc_lib}/lib/ld-linux.so.2"

     

       55
       +
           else if targetPlatform.system == "x86_64-linux"   then "${libc_lib}/lib/ld-linux-x86-64.so.2"

     

       56
       +
           # ARM with a wildcard, which can be "" or "-armhf".

     

       57
       +
           else if (with targetPlatform; isArm && isLinux)   then "${libc_lib}/lib/ld-linux*.so.3"

     

       58
       +
           else if targetPlatform.system == "aarch64-linux"  then "${libc_lib}/lib/ld-linux-aarch64.so.1"

     

       59
       +
           else if targetPlatform.system == "powerpc-linux"  then "${libc_lib}/lib/ld.so.1"

     

       60
       +
           else if targetPlatform.system == "mips64el-linux" then "${libc_lib}/lib/ld.so.1"

     

       61
       +
           else if targetPlatform.isDarwin                   then "/usr/lib/dyld"

     

       62
       +
           else if stdenv.lib.hasSuffix "pc-gnu" targetPlatform.config then "ld.so.1"

     

       63
       +
           else null;

     

       64
       +
       

     

       65
       +
         expand-response-params =

     

       66
       +
           if buildPackages.stdenv.cc or null != null && buildPackages.stdenv.cc != "/dev/null"

     

       67
       +
           then import ../expand-response-params { inherit (buildPackages) stdenv; }

     

       68
       +
           else "";

     

       69
       +
       

     

       70
       +
       in

     

       71
       +
       

     

       72
       +
       stdenv.mkDerivation {

     

       73
       +
         name = targetPrefix

     

       74
       +
           + (if name != "" then name else "${bintoolsName}-wrapper")

     

       75
       +
           + (stdenv.lib.optionalString (bintools != null && bintoolsVersion != "") "-${bintoolsVersion}");

     

       76
       +
       

     

       77
       +
         preferLocalBuild = true;

     

       78
       +
       

     

       79
       +
         inherit bintools_bin libc_bin libc_dev libc_lib coreutils_bin;

     

       80
       +
         shell = getBin shell + shell.shellPath or "";

     

       81
       +
         gnugrep_bin = if nativeTools then "" else gnugrep;

     

       82
       +
       

     

       83
       +
         inherit targetPrefix infixSalt;

     

       84
       +
       

     

       85
       +
         outputs = [ "out" "info" "man" ];

     

       86
       +
       

     

       87
       +
         passthru = {

     

       88
       +
           inherit bintools libc nativeTools nativeLibc nativePrefix;

     

       89
       +
       

     

       90
       +
           emacsBufferSetup = pkgs: ''

     

       91
       +
             ; We should handle propagation here too

     

       92
       +
             (mapc

     

       93
       +
               (lambda (arg)

     

       94
       +
                 (when (file-directory-p (concat arg "/lib"))

     

       95
       +
                   (setenv "NIX_${infixSalt}_LDFLAGS" (concat (getenv "NIX_${infixSalt}_LDFLAGS") " -L" arg "/lib")))

     

       96
       +
                 (when (file-directory-p (concat arg "/lib64"))

     

       97
       +
                   (setenv "NIX_${infixSalt}_LDFLAGS" (concat (getenv "NIX_${infixSalt}_LDFLAGS") " -L" arg "/lib64"))))

     

       98
       +
               '(${concatStringsSep " " (map (pkg: "\"${pkg}\"") pkgs)}))

     

       99
       +
           '';

     

       100
       +
         };

     

       101
       +
       

     

       102
       +
         dontBuild = true;

     

       103
       +
         dontConfigure = true;

     

       104
       +
       

     

       105
       +
         unpackPhase = ''

     

       106
       +
           src=$PWD

     

       107
       +
         '';

     

       108
       +
       

     

       109
       +
         installPhase =

     

       110
       +
           ''

     

       111
       +
             set -u

     

       112
       +
       

     

       113
       +
             mkdir -p $out/bin {$out,$info,$man}/nix-support

     

       114
       +
       

     

       115
       +
             wrap() {

     

       116
       +
               local dst="$1"

     

       117
       +
               local wrapper="$2"

     

       118
       +
               export prog="$3"

     

       119
       +
               set +u

     

       120
       +
               substituteAll "$wrapper" "$out/bin/$dst"

     

       121
       +
               set -u

     

       122
       +
               chmod +x "$out/bin/$dst"

     

       123
       +
             }

     

       124
       +
           ''

     

       125
       +
       

     

       126
       +
           + (if nativeTools then ''

     

       127
       +
             echo ${nativePrefix} > $out/nix-support/orig-bintools

     

       128
       +
       

     

       129
       +
             ldPath="${nativePrefix}/bin"

     

       130
       +
           '' else ''

     

       131
       +
             echo $bintools_bin > $out/nix-support/orig-bintools

     

       132
       +
       

     

       133
       +
             ldPath="${bintools_bin}/bin"

     

       134
       +
           ''

     

       135
       +
       

     

       136
       +
           + optionalString (targetPlatform.isSunOS && nativePrefix != "") ''

     

       137
       +
             # Solaris needs an additional ld wrapper.

     

       138
       +
             ldPath="${nativePrefix}/bin"

     

       139
       +
             exec="$ldPath/${targetPrefix}ld"

     

       140
       +
             wrap ld-solaris ${./ld-solaris-wrapper.sh}

     

       141
       +
           '')

     

       142
       +
       

     

       143
       +
           + ''

     

       144
       +
             # Create a symlink to as (the assembler).

     

       145
       +
             if [ -e $ldPath/${targetPrefix}as ]; then

     

       146
       +
               ln -s $ldPath/${targetPrefix}as $out/bin/${targetPrefix}as

     

       147
       +
             fi

     

       148
       +
       

     

       149
       +
           '' + (if !useMacosReexportHack then ''

     

       150
       +
             wrap ${targetPrefix}ld ${./ld-wrapper.sh} ''${ld:-$ldPath/${targetPrefix}ld}

     

       151
       +
           '' else ''

     

       152
       +
             ldInner="${targetPrefix}ld-reexport-delegate"

     

       153
       +
             wrap "$ldInner" ${./macos-sierra-reexport-hack.bash} ''${ld:-$ldPath/${targetPrefix}ld}

     

       154
       +
             wrap "${targetPrefix}ld" ${./ld-wrapper.sh} "$out/bin/$ldInner"

     

       155
       +
             unset ldInner

     

       156
       +
           '') + ''

     

       157
       +
       

     

       158
       +
             for variant in ld.gold ld.bfd ld.lld; do

     

       159
       +
               local underlying=$ldPath/${targetPrefix}$variant

     

       160
       +
               [[ -e "$underlying" ]] || continue

     

       161
       +
               wrap ${targetPrefix}$variant ${./ld-wrapper.sh} $underlying

     

       162
       +
             done

     

       163
       +
       

     

       164
       +
             set +u

     

       165
       +
           '';

     

       166
       +
       

     

       167
       +
         propagatedBuildInputs = extraPackages;

     

       168
       +
       

     

       169
       +
         setupHook = ./setup-hook.sh;

     

       170
       +
       

     

       171
       +
         postFixup =

     

       172
       +
           ''

     

       173
       +
             set -u

     

       174
       +
           ''

     

       175
       +
       

     

       176
       +
           + optionalString (libc != null) (''

     

       177
       +
             ##

     

       178
       +
             ## General libc support

     

       179
       +
             ##

     

       180
       +
       

     

       181
       +
             echo "-L${libc_lib}/lib" > $out/nix-support/libc-ldflags

     

       182
       +
       

     

       183
       +
             echo "${libc_lib}" > $out/nix-support/orig-libc

     

       184
       +
             echo "${libc_dev}" > $out/nix-support/orig-libc-dev

     

       185
       +
       

     

       186
       +
             ##

     

       187
       +
             ## Dynamic linker support

     

       188
       +
             ##

     

       189
       +
       

     

       190
       +
             if [[ -z ''${dynamicLinker+x} ]]; then

     

       191
       +
               echo "Don't know the name of the dynamic linker for platform '${targetPlatform.config}', so guessing instead." >&2

     

       192
       +
               local dynamicLinker="${libc_lib}/lib/ld*.so.?"

     

       193
       +
             fi

     

       194
       +
       

     

       195
       +
             # Expand globs to fill array of options

     

       196
       +
             dynamicLinker=($dynamicLinker)

     

       197
       +
       

     

       198
       +
             case ''${#dynamicLinker[@]} in

     

       199
       +
               0) echo "No dynamic linker found for platform '${targetPlatform.config}'." >&2;;

     

       200
       +
               1) echo "Using dynamic linker: '$dynamicLinker'" >&2;;

     

       201
       +
               *) echo "Multiple dynamic linkers found for platform '${targetPlatform.config}'." >&2;;

     

       202
       +
             esac

     

       203
       +
       

     

       204
       +
             if [ -n "''${dynamicLinker:-}" ]; then

     

       205
       +
               echo $dynamicLinker > $out/nix-support/dynamic-linker

     

       206
       +
       

     

       207
       +
           '' + (if targetPlatform.isDarwin then ''

     

       208
       +
               printf "export LD_DYLD_PATH=%q\n" "$dynamicLinker" >> $out/nix-support/setup-hook

     

       209
       +
           '' else ''

     

       210
       +
               if [ -e ${libc_lib}/lib/32/ld-linux.so.2 ]; then

     

       211
       +
                 echo ${libc_lib}/lib/32/ld-linux.so.2 > $out/nix-support/dynamic-linker-m32

     

       212
       +
               fi

     

       213
       +
       

     

       214
       +
               local ldflagsBefore=(-dynamic-linker "$dynamicLinker")

     

       215
       +
           '') + ''

     

       216
       +
             fi

     

       217
       +
       

     

       218
       +
             # The dynamic linker is passed in `ldflagsBefore' to allow

     

       219
       +
             # explicit overrides of the dynamic linker by callers to ld

     

       220
       +
             # (the *last* value counts, so ours should come first).

     

       221
       +
             printWords "''${ldflagsBefore[@]}" > $out/nix-support/libc-ldflags-before

     

       222
       +
           '')

     

       223
       +
       

     

       224
       +
           + optionalString (!nativeTools) ''

     

       225
       +
       

     

       226
       +
             ##

     

       227
       +
             ## User env support

     

       228
       +
             ##

     

       229
       +
       

     

       230
       +
             # Propagate the underling unwrapped bintools so that if you

     

       231
       +
             # install the wrapper, you get tools like objdump, the manpages,

     

       232
       +
             # etc. as well (same for any binaries of libc).

     

       233
       +
             printWords ${bintools_bin} ${if libc == null then "" else libc_bin} > $out/nix-support/propagated-user-env-packages

     

       234
       +
       

     

       235
       +
             ##

     

       236
       +
             ## Man page and info support

     

       237
       +
             ##

     

       238
       +
       

     

       239
       +
             printWords ${bintools.info or ""} \

     

       240
       +
               >> $info/nix-support/propagated-build-inputs

     

       241
       +
             printWords ${bintools.man or ""} \

     

       242
       +
               >> $man/nix-support/propagated-build-inputs

     

       243
       +
           ''

     

       244
       +
       

     

       245
       +
           + ''

     

       246
       +
       

     

       247
       +
             ##

     

       248
       +
             ## Hardening support

     

       249
       +
             ##

     

       250
       +
       

     

       251
       +
             # some linkers on some platforms don't support specific -z flags

     

       252
       +
             export hardening_unsupported_flags=""

     

       253
       +
             if [[ "$($ldPath/${targetPrefix}ld -z now 2>&1 || true)" =~ un(recognized|known)\ option ]]; then

     

       254
       +
               hardening_unsupported_flags+=" bindnow"

     

       255
       +
             fi

     

       256
       +
             if [[ "$($ldPath/${targetPrefix}ld -z relro 2>&1 || true)" =~ un(recognized|known)\ option ]]; then

     

       257
       +
               hardening_unsupported_flags+=" relro"

     

       258
       +
             fi

     

       259
       +
           ''

     

       260
       +
       

     

       261
       +
           + optionalString hostPlatform.isCygwin ''

     

       262
       +
             hardening_unsupported_flags+=" pic"

     

       263
       +
           ''

     

       264
       +
       

     

       265
       +
           + ''

     

       266
       +
             set +u

     

       267
       +
             substituteAll ${./add-flags.sh} $out/nix-support/add-flags.sh

     

       268
       +
             substituteAll ${./add-hardening.sh} $out/nix-support/add-hardening.sh

     

       269
       +
             substituteAll ${../cc-wrapper/utils.sh} $out/nix-support/utils.sh

     

       270
       +
       

     

       271
       +
             ##

     

       272
       +
             ## Extra custom steps

     

       273
       +
             ##

     

       274
       +
       

     

       275
       +
           ''

     

       276
       +
           + extraBuildCommands;

     

       277
       +
       

     

       278
       +
         inherit dynamicLinker expand-response-params;

     

       279
       +
       

     

       280
       +
         # for substitution in utils.sh

     

       281
       +
         expandResponseParams = "${expand-response-params}/bin/expand-response-params";

     

       282
       +
       

     

       283
       +
         meta =

     

       284
       +
           let bintools_ = if bintools != null then bintools else {}; in

     

       285
       +
           (if bintools_ ? meta then removeAttrs bintools.meta ["priority"] else {}) //

     

       286
       +
           { description =

     

       287
       +
               stdenv.lib.attrByPath ["meta" "description"] "System binary utilities" bintools_

     

       288
       +
               + " (wrapper script)";

     

       289
       +
         } // optionalAttrs useMacosReexportHack {

     

       290
       +
           platforms = stdenv.lib.platforms.darwin;

     

       291
       +
         };

     

       292
       +
       }

+29

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

···

       1
       +
       #!@shell@

     

       2
       +
       set -eu -o pipefail

     

       3
       +
       shopt -s nullglob

     

       4
       +
       

     

       5
       +
       if (( "${NIX_DEBUG:-0}" >= 7 )); then

     

       6
       +
           set -x

     

       7
       +
       fi

     

       8
       +
       

     

       9
       +
       declare -a args=("$@")

     

       10
       +
       # I've also tried adding -z direct and -z lazyload, but it gave too many problems with C++ exceptions :'(

     

       11
       +
       # Also made sure libgcc would not be lazy-loaded, as suggested here: https://www.illumos.org/issues/2534#note-3

     

       12
       +
       #   but still no success.

     

       13
       +
       declare -a argsBefore=(-z ignore) argsAfter=()

     

       14
       +
       

     

       15
       +
       # This loop makes sure all -L arguments are before -l arguments, or ld may complain it cannot find a library.

     

       16
       +
       # GNU binutils does not have this problem:

     

       17
       +
       #   http://stackoverflow.com/questions/5817269/does-the-order-of-l-and-l-options-in-the-gnu-linker-matter

     

       18
       +
       while (( $# )); do

     

       19
       +
           case "${args[$i]}" in

     

       20
       +
               -L)   argsBefore+=("$1" "$2"); shift ;;

     

       21
       +
               -L?*) argsBefore+=("$1") ;;

     

       22
       +
               *)    argsAfter+=("$1") ;;

     

       23
       +
           esac

     

       24
       +
           shift

     

       25
       +
       done

     

       26
       +
       

     

       27
       +
       # Trace:

     

       28
       +
       set -x

     

       29
       +
       exec "@ld@" "${argsBefore[@]}" "${argsAfter[@]}"

+67

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

···

       1
       +
       # Binutils Wrapper hygiene

     

       2
       +
       #

     

       3
       +
       # See comments in cc-wrapper's setup hook. This works exactly the same way.

     

       4
       +
       

     

       5
       +
       bintoolsWrapper_addLDVars () {

     

       6
       +
           case $depOffset in

     

       7
       +
               -1) local role='BUILD_' ;;

     

       8
       +
               0)  local role='' ;;

     

       9
       +
               1)  local role='TARGET_' ;;

     

       10
       +
               *)  echo "bintools-wrapper: Error: Cannot be used with $depOffset-offset deps, " >2;

     

       11
       +
                   return 1 ;;

     

       12
       +
           esac

     

       13
       +
       

     

       14
       +
           if [[ -d "$1/lib64" && ! -L "$1/lib64" ]]; then

     

       15
       +
               export NIX_${role}LDFLAGS+=" -L$1/lib64"

     

       16
       +
           fi

     

       17
       +
       

     

       18
       +
           if [[ -d "$1/lib" ]]; then

     

       19
       +
               export NIX_${role}LDFLAGS+=" -L$1/lib"

     

       20
       +
           fi

     

       21
       +
       }

     

       22
       +
       

     

       23
       +
       if [ -n "${crossConfig:-}" ]; then

     

       24
       +
           export NIX_BINTOOLS_WRAPPER_@infixSalt@_TARGET_BUILD=1

     

       25
       +
           role_pre='BUILD_'

     

       26
       +
           role_post='_FOR_BUILD'

     

       27
       +
       else

     

       28
       +
           export NIX_BINTOOLS_WRAPPER_@infixSalt@_TARGET_HOST=1

     

       29
       +
           role_pre=""

     

       30
       +
           role_post=''

     

       31
       +
       fi

     

       32
       +
       

     

       33
       +
       envHooks+=(bintoolsWrapper_addLDVars)

     

       34
       +
       

     

       35
       +
       # shellcheck disable=SC2157

     

       36
       +
       if [ -n "@bintools_bin@" ]; then

     

       37
       +
           addToSearchPath _PATH @bintools_bin@/bin

     

       38
       +
       fi

     

       39
       +
       

     

       40
       +
       # shellcheck disable=SC2157

     

       41
       +
       if [ -n "@libc_bin@" ]; then

     

       42
       +
           addToSearchPath _PATH @libc_bin@/bin

     

       43
       +
       fi

     

       44
       +
       

     

       45
       +
       # shellcheck disable=SC2157

     

       46
       +
       if [ -n "@coreutils_bin@" ]; then

     

       47
       +
           addToSearchPath _PATH @coreutils_bin@/bin

     

       48
       +
       fi

     

       49
       +
       

     

       50
       +
       # Export tool environment variables so various build systems use the right ones.

     

       51
       +
       

     

       52
       +
       export NIX_${role_pre}BINTOOLS=@out@

     

       53
       +
       

     

       54
       +
       for cmd in \

     

       55
       +
           ar as ld nm objcopy objdump readelf ranlib strip strings size windres

     

       56
       +
       do

     

       57
       +
           if

     

       58
       +
               PATH=$_PATH type -p "@targetPrefix@${cmd}" > /dev/null

     

       59
       +
           then

     

       60
       +
               upper_case="$(echo "$cmd" | tr "[:lower:]" "[:upper:]")"

     

       61
       +
               export "${role_pre}${upper_case}=@targetPrefix@${cmd}";

     

       62
       +
               export "${upper_case}${role_post}=@targetPrefix@${cmd}";

     

       63
       +
           fi

     

       64
       +
       done

     

       65
       +
       

     

       66
       +
       # No local scope in sourced file

     

       67
       +
       unset -v role_pre role_post cmd upper_case

+8 -27

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

···

       4
        
       # that case, it is cheaper/better to not repeat this step and let the forked

     

       5
        
       # wrapped binary just inherit the work of the forker's wrapper script.

     

       6
        
       

     

       7
       -
       var_templates=(

     

       8
        
           NIX+CFLAGS_COMPILE

     

       9
        
           NIX+CFLAGS_LINK

     

       10
        
           NIX+CXXSTDLIB_COMPILE

     

       11
        
           NIX+CXXSTDLIB_LINK

     

       12
        
           NIX+GNATFLAGS_COMPILE

     

       13
       -
           NIX+IGNORE_LD_THROUGH_GCC

     

       14
       -
           NIX+LDFLAGS

     

       15
       -
           NIX+LDFLAGS_BEFORE

     

       16
       -
           NIX+LDFLAGS_AFTER

     

       17
       -
       

     

       18
       -
           NIX+SET_BUILD_ID

     

       19
       -
           NIX+DONT_SET_RPATH

     

       20
        
           NIX+ENFORCE_NO_NATIVE

     

       21
        
       )

     

       22
        
       

     
···

       35
        
       

     

       36
        
       # We need to mangle names for hygiene, but also take parameters/overrides

     

       37
        
       # from the environment.

     

       38
       -
       for var in "${var_templates[@]}"; do

     

       39
       -
           outputVar="${var/+/_@infixSalt@_}"

     

       40
       -
           export ${outputVar}+=''

     

       41
       -
           # For each role we serve, we accumulate the input parameters into our own

     

       42
       -
           # cc-wrapper-derivation-specific environment variables.

     

       43
       -
           for infix in "${role_infixes[@]}"; do

     

       44
       -
               inputVar="${var/+/${infix}}"

     

       45
       -
               if [ -v "$inputVar" ]; then

     

       46
       -
                   export ${outputVar}+="${!outputVar:+ }${!inputVar}"

     

       47
       -
               fi

     

       48
       -
           done

     

       49
        
       done

     

       50
        
       

     

       51
        
       # `-B@out@/bin' forces cc to use ld-wrapper.sh when calling ld.

     
···

       66
        
           NIX_@infixSalt@_GNATFLAGS_COMPILE="$(< @out@/nix-support/gnat-cflags) $NIX_@infixSalt@_GNATFLAGS_COMPILE"

     

       67
        
       fi

     

       68
        
       

     

       69
       -
       if [ -e @out@/nix-support/libc-ldflags ]; then

     

       70
       -
           NIX_@infixSalt@_LDFLAGS+=" $(< @out@/nix-support/libc-ldflags)"

     

       71
       -
       fi

     

       72
       -
       

     

       73
        
       if [ -e @out@/nix-support/cc-ldflags ]; then

     

       74
        
           NIX_@infixSalt@_LDFLAGS+=" $(< @out@/nix-support/cc-ldflags)"

     

       75
       -
       fi

     

       76
       -
       

     

       77
       -
       if [ -e @out@/nix-support/libc-ldflags-before ]; then

     

       78
       -
           NIX_@infixSalt@_LDFLAGS_BEFORE="$(< @out@/nix-support/libc-ldflags-before) $NIX_@infixSalt@_LDFLAGS_BEFORE"

     

       79
        
       fi

     

       80
        
       

     

       81
        
       # That way forked processes will not extend these environment variables again.

···

       4
        
       # that case, it is cheaper/better to not repeat this step and let the forked

     

       5
        
       # wrapped binary just inherit the work of the forker's wrapper script.

     

       6
        
       

     

       7
       +
       var_templates_list=(

     

       8
        
           NIX+CFLAGS_COMPILE

     

       9
        
           NIX+CFLAGS_LINK

     

       10
        
           NIX+CXXSTDLIB_COMPILE

     

       11
        
           NIX+CXXSTDLIB_LINK

     

       12
        
           NIX+GNATFLAGS_COMPILE

     

       13
       +
       )

     

       14
       +
       var_templates_bool=(

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
           NIX+ENFORCE_NO_NATIVE

     

       16
        
       )

     

       17
        
       

     
···

       30
        
       

     

       31
        
       # We need to mangle names for hygiene, but also take parameters/overrides

     

       32
        
       # from the environment.

     

       33
       +
       for var in "${var_templates_list[@]}"; do

     

       34
       +
           mangleVarList "$var" "${role_infixes[@]}"

     

       35
       +
       done

     

       36
       +
       for var in "${var_templates_bool[@]}"; do

     

       37
       +
           mangleVarBool "$var" "${role_infixes[@]}"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       38
        
       done

     

       39
        
       

     

       40
        
       # `-B@out@/bin' forces cc to use ld-wrapper.sh when calling ld.

     
···

       55
        
           NIX_@infixSalt@_GNATFLAGS_COMPILE="$(< @out@/nix-support/gnat-cflags) $NIX_@infixSalt@_GNATFLAGS_COMPILE"

     

       56
        
       fi

     

       57
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       58
        
       if [ -e @out@/nix-support/cc-ldflags ]; then

     

       59
        
           NIX_@infixSalt@_LDFLAGS+=" $(< @out@/nix-support/cc-ldflags)"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       60
        
       fi

     

       61
        
       

     

       62
        
       # That way forked processes will not extend these environment variables again.

-10

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

···

       6
        
         hardeningFlags+=(${hardeningEnable[@]})

     

       7
        
       fi

     

       8
        
       hardeningCFlags=()

     

       9
       -
       hardeningLDFlags=()

     

       10
        
       

     

       11
        
       declare -A hardeningDisableMap

     

       12
        
       

     
···

       44
        
                 if [[ ! ("$*" =~ " -shared " || "$*" =~ " -static ") ]]; then

     

       45
        
                   if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling LDFlags -pie >&2; fi

     

       46
        
                   hardeningCFlags+=('-pie')

     

       47
       -
                   hardeningLDFlags+=('-pie')

     

       48
        
                 fi

     

       49
        
                 ;;

     

       50
        
               pic)

     
···

       58
        
               format)

     

       59
        
                 if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling format >&2; fi

     

       60
        
                 hardeningCFlags+=('-Wformat' '-Wformat-security' '-Werror=format-security')

     

       61
       -
                 ;;

     

       62
       -
               relro)

     

       63
       -
                 if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling relro >&2; fi

     

       64
       -
                 hardeningLDFlags+=('-z' 'relro')

     

       65
       -
                 ;;

     

       66
       -
               bindnow)

     

       67
       -
                 if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling bindnow >&2; fi

     

       68
       -
                 hardeningLDFlags+=('-z' 'now')

     

       69
        
                 ;;

     

       70
        
               *)

     

       71
        
                 # Ignore unsupported. Checked in Nix that at least *some*

···

       6
        
         hardeningFlags+=(${hardeningEnable[@]})

     

       7
        
       fi

     

       8
        
       hardeningCFlags=()

     

       0
        
       
     

       9
        
       

     

       10
        
       declare -A hardeningDisableMap

     

       11
        
       

     
···

       43
        
                 if [[ ! ("$*" =~ " -shared " || "$*" =~ " -static ") ]]; then

     

       44
        
                   if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling LDFlags -pie >&2; fi

     

       45
        
                   hardeningCFlags+=('-pie')

     

       0
        
       
     

       46
        
                 fi

     

       47
        
                 ;;

     

       48
        
               pic)

     
···

       56
        
               format)

     

       57
        
                 if (( "${NIX_DEBUG:-0}" >= 1 )); then echo HARDENING: enabling format >&2; fi

     

       58
        
                 hardeningCFlags+=('-Wformat' '-Wformat-security' '-Werror=format-security')

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       59
        
                 ;;

     

       60
        
               *)

     

       61
        
                 # Ignore unsupported. Checked in Nix that at least *some*

+10 -3

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

···

       15
        
           PATH="@coreutils_bin@/bin:@gnugrep_bin@/bin"

     

       16
        
       fi

     

       17
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
       if [ -z "${NIX_CC_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then

     

       19
        
           source @out@/nix-support/add-flags.sh

     

       20
        
       fi

     

       21
       -
       

     

       22
       -
       source @out@/nix-support/utils.sh

     

       23
        
       

     

       24
        
       

     

       25
        
       # Parse command line options and set several variables.

     
···

       59
        
               cppInclude=0

     

       60
        
           elif [ "$p" = -nostdinc++ ]; then

     

       61
        
               cppInclude=0

     

       62
       -
           elif [ "${p:0:1}" != - ]; then

     

       0
        
       
     

       63
        
               nonFlagArgs=1

     

       64
        
           fi

     

       65
        
           n+=1

···

       15
        
           PATH="@coreutils_bin@/bin:@gnugrep_bin@/bin"

     

       16
        
       fi

     

       17
        
       

     

       18
       +
       source @out@/nix-support/utils.sh

     

       19
       +
       

     

       20
       +
       # Flirting with a layer violation here.

     

       21
       +
       if [ -z "${NIX_BINTOOLS_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then

     

       22
       +
           source @bintools@/nix-support/add-flags.sh

     

       23
       +
       fi

     

       24
       +
       

     

       25
       +
       # Put this one second so libc ldflags take priority.

     

       26
        
       if [ -z "${NIX_CC_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then

     

       27
        
           source @out@/nix-support/add-flags.sh

     

       28
        
       fi

     

       0
        
       
     

       0
        
       
     

       29
        
       

     

       30
        
       

     

       31
        
       # Parse command line options and set several variables.

     
···

       65
        
               cppInclude=0

     

       66
        
           elif [ "$p" = -nostdinc++ ]; then

     

       67
        
               cppInclude=0

     

       68
       +
           elif [[ "$p" != -?* ]]; then

     

       69
       +
               # A dash alone signifies standard input; it is not a flag

     

       70
        
               nonFlagArgs=1

     

       71
        
           fi

     

       72
        
           n+=1

+41 -116

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

···

       6
        
       # compiler and the linker just "work".

     

       7
        
       

     

       8
        
       { name ? "", stdenvNoCC, nativeTools, noLibc ? false, nativeLibc, nativePrefix ? ""

     

       9
       -
       , cc ? null, libc ? null, binutils ? null, coreutils ? null, shell ? stdenvNoCC.shell

     

       10
        
       , zlib ? null, extraPackages ? [], extraBuildCommands ? ""

     

       11
        
       , isGNU ? false, isClang ? cc.isClang or false, gnugrep ? null

     

       12
        
       , buildPackages ? {}

     

       13
       -
       , useMacosReexportHack ? false

     

       14
        
       }:

     

       15
        
       

     

       16
        
       with stdenvNoCC.lib;

     

       17
        
       

     

       18
        
       assert nativeTools -> nativePrefix != "";

     

       19
        
       assert !nativeTools ->

     

       20
       -
         cc != null && binutils != null && coreutils != null && gnugrep != null;

     

       21
        
       assert !(nativeLibc && noLibc);

     

       22
        
       assert (noLibc || nativeLibc) == (libc == null);

     

       23
        
       

     
···

       42
        
         libc_dev = if libc == null then null else getDev libc;

     

       43
        
         libc_lib = if libc == null then null else getLib libc;

     

       44
        
         cc_solib = getLib cc;

     

       45
       -
         binutils_bin = if nativeTools then "" else getBin binutils;

     

       46
        
         # The wrapper scripts use 'cat' and 'grep', so we may need coreutils.

     

       47
        
         coreutils_bin = if nativeTools then "" else getBin coreutils;

     

       48
        
       

     
···

       58
        
         # unstable implementation detail, however.

     

       59
        
         infixSalt = dashlessTarget;

     

       60
        
       

     

       61
       -
         # The dynamic linker has different names on different platforms. This is a

     

       62
       -
         # shell glob that ought to match it.

     

       63
       -
         dynamicLinker =

     

       64
       -
           /**/ if libc == null then null

     

       65
       -
           else if targetPlatform.system == "i686-linux"     then "${libc_lib}/lib/ld-linux.so.2"

     

       66
       -
           else if targetPlatform.system == "x86_64-linux"   then "${libc_lib}/lib/ld-linux-x86-64.so.2"

     

       67
       -
           # ARM with a wildcard, which can be "" or "-armhf".

     

       68
       -
           else if (with targetPlatform; isArm && isLinux)   then "${libc_lib}/lib/ld-linux*.so.3"

     

       69
       -
           else if targetPlatform.system == "aarch64-linux"  then "${libc_lib}/lib/ld-linux-aarch64.so.1"

     

       70
       -
           else if targetPlatform.system == "powerpc-linux"  then "${libc_lib}/lib/ld.so.1"

     

       71
       -
           else if targetPlatform.system == "mips64el-linux" then "${libc_lib}/lib/ld.so.1"

     

       72
       -
           else if targetPlatform.isDarwin                   then "/usr/lib/dyld"

     

       73
       -
           else if stdenv.lib.hasSuffix "pc-gnu" targetPlatform.config then "ld.so.1"

     

       74
       -
           else null;

     

       75
       -
       

     

       76
        
         expand-response-params =

     

       77
        
           if buildPackages.stdenv.cc or null != null && buildPackages.stdenv.cc != "/dev/null"

     

       78
        
           then import ../expand-response-params { inherit (buildPackages) stdenv; }

     
···

       80
        
       

     

       81
        
       in

     

       82
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       83
        
       stdenv.mkDerivation {

     

       84
        
         name = targetPrefix

     

       85
        
           + (if name != "" then name else "${ccName}-wrapper")

     
···

       87
        
       

     

       88
        
         preferLocalBuild = true;

     

       89
        
       

     

       90
       -
         inherit cc libc_bin libc_dev libc_lib binutils_bin coreutils_bin;

     

       91
       -
         shell = getBin shell + shell.shellPath or "";

     

       92
        
         gnugrep_bin = if nativeTools then "" else gnugrep;

     

       93
        
       

     

       94
        
         inherit targetPrefix infixSalt;

     
···

       98
        
         passthru = {

     

       99
        
           # "cc" is the generic name for a C compiler, but there is no one for package

     

       100
        
           # providing the linker and related tools. The two we use now are GNU

     

       101
       -
           # Binutils, and Apple's "cctools"; "binutils" as an attempt to find an

     

       102
        
           # unused middle-ground name that evokes both.

     

       103
       -
           bintools = binutils_bin;

     

       104
        
           inherit libc nativeTools nativeLibc nativePrefix isGNU isClang default_cxx_stdlib_compile;

     

       105
        
       

     

       106
        
           emacsBufferSetup = pkgs: ''

     

       107
        
             ; We should handle propagation here too

     

       108
       -
             (mapc (lambda (arg)

     

       109
       -
               (when (file-directory-p (concat arg "/include"))

     

       110
       -
                 (setenv "NIX_${infixSalt}_CFLAGS_COMPILE" (concat (getenv "NIX_${infixSalt}_CFLAGS_COMPILE") " -isystem " arg "/include")))

     

       111
       -
               (when (file-directory-p (concat arg "/lib"))

     

       112
       -
                 (setenv "NIX_${infixSalt}_LDFLAGS" (concat (getenv "NIX_${infixSalt}_LDFLAGS") " -L" arg "/lib")))

     

       113
       -
               (when (file-directory-p (concat arg "/lib64"))

     

       114
       -
                 (setenv "NIX_${infixSalt}_LDFLAGS" (concat (getenv "NIX_${infixSalt}_LDFLAGS") " -L" arg "/lib64")))) '(${concatStringsSep " " (map (pkg: "\"${pkg}\"") pkgs)}))

     

       115
        
           '';

     

       116
        
         };

     

       117
        
       

     
···

       141
        
             echo ${if targetPlatform.isDarwin then cc else nativePrefix} > $out/nix-support/orig-cc

     

       142
        
       

     

       143
        
             ccPath="${if targetPlatform.isDarwin then cc else nativePrefix}/bin"

     

       144
       -
             ldPath="${nativePrefix}/bin"

     

       145
        
           '' else ''

     

       146
        
             echo $cc > $out/nix-support/orig-cc

     

       147
        
       

     

       148
        
             ccPath="${cc}/bin"

     

       149
       -
             ldPath="${binutils_bin}/bin"

     

       150
       -
           ''

     

       151
       -
       

     

       152
       -
           + optionalString (targetPlatform.isSunOS && nativePrefix != "") ''

     

       153
       -
             # Solaris needs an additional ld wrapper.

     

       154
       -
             ldPath="${nativePrefix}/bin"

     

       155
       -
             exec="$ldPath/${targetPrefix}ld"

     

       156
       -
             wrap ld-solaris ${./ld-solaris-wrapper.sh}

     

       157
        
           '')

     

       158
        
       

     

       159
        
           + ''

     

       160
       -
             # Create a symlink to as (the assembler).  This is useful when a

     

       161
       -
             # cc-wrapper is installed in a user environment, as it ensures that

     

       162
       -
             # the right assembler is called.

     

       163
       -
             if [ -e $ldPath/${targetPrefix}as ]; then

     

       164
       -
               ln -s $ldPath/${targetPrefix}as $out/bin/${targetPrefix}as

     

       165
       -
             fi

     

       166
       -
       

     

       167
       -
           '' + (if !useMacosReexportHack then ''

     

       168
       -
             wrap ${targetPrefix}ld ${./ld-wrapper.sh} ''${ld:-$ldPath/${targetPrefix}ld}

     

       169
       -
           '' else ''

     

       170
       -
             ldInner="${targetPrefix}ld-reexport-delegate"

     

       171
       -
             wrap "$ldInner" ${./macos-sierra-reexport-hack.bash} ''${ld:-$ldPath/${targetPrefix}ld}

     

       172
       -
             wrap "${targetPrefix}ld" ${./ld-wrapper.sh} "$out/bin/$ldInner"

     

       173
       -
             unset ldInner

     

       174
       -
           '') + ''

     

       175
       -
       

     

       176
       -
             if [ -e ${binutils_bin}/bin/${targetPrefix}ld.gold ]; then

     

       177
       -
               wrap ${targetPrefix}ld.gold ${./ld-wrapper.sh} ${binutils_bin}/bin/${targetPrefix}ld.gold

     

       178
       -
             fi

     

       179
       -
       

     

       180
       -
             if [ -e ${binutils_bin}/bin/ld.bfd ]; then

     

       181
       -
               wrap ${targetPrefix}ld.bfd ${./ld-wrapper.sh} ${binutils_bin}/bin/${targetPrefix}ld.bfd

     

       182
       -
             fi

     

       183
        
       

     

       184
        
             # We export environment variables pointing to the wrapped nonstandard

     

       185
        
             # cmds, lest some lousy configure script use those to guess compiler

     
···

       239
        
             ln -s $ccPath/${targetPrefix}ghdl $out/bin/${targetPrefix}ghdl

     

       240
        
           '';

     

       241
        
       

     

       242
       -
         propagatedBuildInputs = extraPackages;

     

       243
        
       

     

       244
        
         setupHook = ./setup-hook.sh;

     

       245
        
       

     

       246
        
         postFixup =

     

       247
        
           ''

     

       248
        
             set -u

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       249
        
           ''

     

       250
        
       

     

       251
       -
           + optionalString (libc != null) (''

     

       252
        
             ##

     

       253
        
             ## General libc support

     

       254
        
             ##

     
···

       264
        
             # compile, because it uses "#include_next <limits.h>" to find the

     

       265
        
             # limits.h file in ../includes-fixed. To remedy the problem,

     

       266
        
             # another -idirafter is necessary to add that directory again.

     

       267
       -
             echo "-B${libc_lib}/lib/ -idirafter ${libc_dev}/include -idirafter ${cc}/lib/gcc/*/*/include-fixed" > $out/nix-support/libc-cflags

     

       268
       -
       

     

       269
       -
             echo "-L${libc_lib}/lib" > $out/nix-support/libc-ldflags

     

       270
        
       

     

       271
        
             echo "${libc_lib}" > $out/nix-support/orig-libc

     

       272
        
             echo "${libc_dev}" > $out/nix-support/orig-libc-dev

     

       273
       -
       

     

       274
       -
             ##

     

       275
       -
             ## Dynamic linker support

     

       276
       -
             ##

     

       277
       -
       

     

       278
       -
             if [[ -z ''${dynamicLinker+x} ]]; then

     

       279
       -
               echo "Don't know the name of the dynamic linker for platform '${targetPlatform.config}', so guessing instead." >&2

     

       280
       -
               local dynamicLinker="${libc_lib}/lib/ld*.so.?"

     

       281
       -
             fi

     

       282
       -
       

     

       283
       -
             # Expand globs to fill array of options

     

       284
       -
             dynamicLinker=($dynamicLinker)

     

       285
       -
       

     

       286
       -
             case ''${#dynamicLinker[@]} in

     

       287
       -
               0) echo "No dynamic linker found for platform '${targetPlatform.config}'." >&2;;

     

       288
       -
               1) echo "Using dynamic linker: '$dynamicLinker'" >&2;;

     

       289
       -
               *) echo "Multiple dynamic linkers found for platform '${targetPlatform.config}'." >&2;;

     

       290
       -
             esac

     

       291
       -
       

     

       292
       -
             if [ -n "''${dynamicLinker:-}" ]; then

     

       293
       -
               echo $dynamicLinker > $out/nix-support/dynamic-linker

     

       294
       -
       

     

       295
       -
           '' + (if targetPlatform.isDarwin then ''

     

       296
       -
               printf "export LD_DYLD_PATH=%q\n" "$dynamicLinker" >> $out/nix-support/setup-hook

     

       297
       -
           '' else ''

     

       298
       -
               if [ -e ${libc_lib}/lib/32/ld-linux.so.2 ]; then

     

       299
       -
                 echo ${libc_lib}/lib/32/ld-linux.so.2 > $out/nix-support/dynamic-linker-m32

     

       300
       -
               fi

     

       301
       -
       

     

       302
       -
               local ldflagsBefore=(-dynamic-linker "$dynamicLinker")

     

       303
       -
           '') + ''

     

       304
       -
             fi

     

       305
       -
       

     

       306
       -
             # The dynamic linker is passed in `ldflagsBefore' to allow

     

       307
       -
             # explicit overrides of the dynamic linker by callers to gcc/ld

     

       308
       -
             # (the *last* value counts, so ours should come first).

     

       309
       -
             printWords "''${ldflagsBefore[@]}" > $out/nix-support/libc-ldflags-before

     

       310
       -
           '')

     

       311
        
       

     

       312
        
           + optionalString (!nativeTools) ''

     

       313
        
       

     
···

       348
        
             # Propagate the wrapped cc so that if you install the wrapper,

     

       349
        
             # you get tools like gcov, the manpages, etc. as well (including

     

       350
        
             # for binutils and Glibc).

     

       351
       -
             printWords ${cc} ${binutils_bin} ${if libc == null then "" else libc_bin} > $out/nix-support/propagated-user-env-packages

     

       352
        
             printWords ${cc.man or ""}  > $man/nix-support/propagated-user-env-packages

     

       353
        
           ''

     

       354
        
       

     
···

       358
        
             ## Hardening support

     

       359
        
             ##

     

       360
        
       

     

       361
       -
             # some linkers on some platforms don't support specific -z flags

     

       362
        
             export hardening_unsupported_flags=""

     

       363
       -
             if [[ "$($ldPath/${targetPrefix}ld -z now 2>&1 || true)" =~ un(recognized|known)\ option ]]; then

     

       364
       -
               hardening_unsupported_flags+=" bindnow"

     

       365
       -
             fi

     

       366
       -
             if [[ "$($ldPath/${targetPrefix}ld -z relro 2>&1 || true)" =~ un(recognized|known)\ option ]]; then

     

       367
       -
               hardening_unsupported_flags+=" relro"

     

       368
       -
             fi

     

       369
        
           ''

     

       370
        
       

     

       371
        
           + optionalString hostPlatform.isCygwin ''

     
···

       384
        
           ''

     

       385
        
           + extraBuildCommands;

     

       386
        
       

     

       387
       -
         inherit dynamicLinker expand-response-params;

     

       388
        
       

     

       389
        
         # for substitution in utils.sh

     

       390
        
         expandResponseParams = "${expand-response-params}/bin/expand-response-params";

     
···

       395
        
           { description =

     

       396
        
               stdenv.lib.attrByPath ["meta" "description"] "System C compiler" cc_

     

       397
        
               + " (wrapper script)";

     

       398
       -
         } // optionalAttrs useMacosReexportHack {

     

       399
       -
           platforms = stdenv.lib.platforms.darwin;

     

       400
        
         };

     

       401
        
       }

···

       6
        
       # compiler and the linker just "work".

     

       7
        
       

     

       8
        
       { name ? "", stdenvNoCC, nativeTools, noLibc ? false, nativeLibc, nativePrefix ? ""

     

       9
       +
       , cc ? null, libc ? null, bintools, coreutils ? null, shell ? stdenvNoCC.shell

     

       10
        
       , zlib ? null, extraPackages ? [], extraBuildCommands ? ""

     

       11
        
       , isGNU ? false, isClang ? cc.isClang or false, gnugrep ? null

     

       12
        
       , buildPackages ? {}

     

       0
        
       
     

       13
        
       }:

     

       14
        
       

     

       15
        
       with stdenvNoCC.lib;

     

       16
        
       

     

       17
        
       assert nativeTools -> nativePrefix != "";

     

       18
        
       assert !nativeTools ->

     

       19
       +
         cc != null && coreutils != null && gnugrep != null;

     

       20
        
       assert !(nativeLibc && noLibc);

     

       21
        
       assert (noLibc || nativeLibc) == (libc == null);

     

       22
        
       

     
···

       41
        
         libc_dev = if libc == null then null else getDev libc;

     

       42
        
         libc_lib = if libc == null then null else getLib libc;

     

       43
        
         cc_solib = getLib cc;

     

       0
        
       
     

       44
        
         # The wrapper scripts use 'cat' and 'grep', so we may need coreutils.

     

       45
        
         coreutils_bin = if nativeTools then "" else getBin coreutils;

     

       46
        
       

     
···

       56
        
         # unstable implementation detail, however.

     

       57
        
         infixSalt = dashlessTarget;

     

       58
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       59
        
         expand-response-params =

     

       60
        
           if buildPackages.stdenv.cc or null != null && buildPackages.stdenv.cc != "/dev/null"

     

       61
        
           then import ../expand-response-params { inherit (buildPackages) stdenv; }

     
···

       63
        
       

     

       64
        
       in

     

       65
        
       

     

       66
       +
       # Ensure bintools matches

     

       67
       +
       assert libc_bin == bintools.libc_bin;

     

       68
       +
       assert libc_dev == bintools.libc_dev;

     

       69
       +
       assert libc_lib == bintools.libc_lib;

     

       70
       +
       assert nativeTools == bintools.nativeTools;

     

       71
       +
       assert nativeLibc == bintools.nativeLibc;

     

       72
       +
       assert nativePrefix == bintools.nativePrefix;

     

       73
       +
       

     

       74
        
       stdenv.mkDerivation {

     

       75
        
         name = targetPrefix

     

       76
        
           + (if name != "" then name else "${ccName}-wrapper")

     
···

       78
        
       

     

       79
        
         preferLocalBuild = true;

     

       80
        
       

     

       81
       +
         inherit cc libc_bin libc_dev libc_lib bintools coreutils_bin;

     

       82
       +
         shell = getBin shell + stdenv.lib.optionalString (stdenv ? shellPath) stdenv.shellPath;

     

       83
        
         gnugrep_bin = if nativeTools then "" else gnugrep;

     

       84
        
       

     

       85
        
         inherit targetPrefix infixSalt;

     
···

       89
        
         passthru = {

     

       90
        
           # "cc" is the generic name for a C compiler, but there is no one for package

     

       91
        
           # providing the linker and related tools. The two we use now are GNU

     

       92
       +
           # Binutils, and Apple's "cctools"; "bintools" as an attempt to find an

     

       93
        
           # unused middle-ground name that evokes both.

     

       94
       +
           inherit bintools;

     

       95
        
           inherit libc nativeTools nativeLibc nativePrefix isGNU isClang default_cxx_stdlib_compile;

     

       96
        
       

     

       97
        
           emacsBufferSetup = pkgs: ''

     

       98
        
             ; We should handle propagation here too

     

       99
       +
             (mapc

     

       100
       +
               (lambda (arg)

     

       101
       +
                 (when (file-directory-p (concat arg "/include"))

     

       102
       +
                   (setenv "NIX_${infixSalt}_CFLAGS_COMPILE" (concat (getenv "NIX_${infixSalt}_CFLAGS_COMPILE") " -isystem " arg "/include"))))

     

       103
       +
               '(${concatStringsSep " " (map (pkg: "\"${pkg}\"") pkgs)}))

     

       0
        
       
     

       0
        
       
     

       104
        
           '';

     

       105
        
         };

     

       106
        
       

     
···

       130
        
             echo ${if targetPlatform.isDarwin then cc else nativePrefix} > $out/nix-support/orig-cc

     

       131
        
       

     

       132
        
             ccPath="${if targetPlatform.isDarwin then cc else nativePrefix}/bin"

     

       0
        
       
     

       133
        
           '' else ''

     

       134
        
             echo $cc > $out/nix-support/orig-cc

     

       135
        
       

     

       136
        
             ccPath="${cc}/bin"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       137
        
           '')

     

       138
        
       

     

       139
        
           + ''

     

       140
       +
             # Create symlinks to everything in the bintools wrapper.

     

       141
       +
             for bbin in $bintools/bin/*; do

     

       142
       +
               mkdir -p "$out/bin"

     

       143
       +
               ln -s "$bbin" "$out/bin/$(basename $bbin)"

     

       144
       +
             done

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       145
        
       

     

       146
        
             # We export environment variables pointing to the wrapped nonstandard

     

       147
        
             # cmds, lest some lousy configure script use those to guess compiler

     
···

       201
        
             ln -s $ccPath/${targetPrefix}ghdl $out/bin/${targetPrefix}ghdl

     

       202
        
           '';

     

       203
        
       

     

       204
       +
         propagatedBuildInputs = [ bintools ] ++ extraPackages;

     

       205
        
       

     

       206
        
         setupHook = ./setup-hook.sh;

     

       207
        
       

     

       208
        
         postFixup =

     

       209
        
           ''

     

       210
        
             set -u

     

       211
       +
       

     

       212
       +
             # Backwards compatability for packages expecting this file, e.g. with

     

       213
       +
             # `$NIX_CC/nix-support/dynamic-linker`.

     

       214
       +
             #

     

       215
       +
             # TODO(@Ericson2314): Remove this after stable release and force

     

       216
       +
             # everyone to refer to bintools-wrapper directly.

     

       217
       +
             if [[ -f "$bintools/nix-support/dynamic-linker" ]]; then

     

       218
       +
               ln -s "$bintools/nix-support/dynamic-linker" "$out/nix-support"

     

       219
       +
             fi

     

       220
       +
             if [[ -f "$bintools/nix-support/dynamic-linker-m32" ]]; then

     

       221
       +
               ln -s "$bintools/nix-support/dynamic-linker-m32" "$out/nix-support"

     

       222
       +
             fi

     

       223
        
           ''

     

       224
        
       

     

       225
       +
           + optionalString (libc != null) ''

     

       226
        
             ##

     

       227
        
             ## General libc support

     

       228
        
             ##

     
···

       238
        
             # compile, because it uses "#include_next <limits.h>" to find the

     

       239
        
             # limits.h file in ../includes-fixed. To remedy the problem,

     

       240
        
             # another -idirafter is necessary to add that directory again.

     

       241
       +
             echo "-B${libc_lib}/lib/ -idirafter ${libc_dev}/include ${optionalString isGNU "-idirafter ${cc}/lib/gcc/*/*/include-fixed"}" > $out/nix-support/libc-cflags

     

       0
        
       
     

       0
        
       
     

       242
        
       

     

       243
        
             echo "${libc_lib}" > $out/nix-support/orig-libc

     

       244
        
             echo "${libc_dev}" > $out/nix-support/orig-libc-dev

     

       245
       +
           ''

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       246
        
       

     

       247
        
           + optionalString (!nativeTools) ''

     

       248
        
       

     
···

       283
        
             # Propagate the wrapped cc so that if you install the wrapper,

     

       284
        
             # you get tools like gcov, the manpages, etc. as well (including

     

       285
        
             # for binutils and Glibc).

     

       0
        
       
     

       286
        
             printWords ${cc.man or ""}  > $man/nix-support/propagated-user-env-packages

     

       287
        
           ''

     

       288
        
       

     
···

       292
        
             ## Hardening support

     

       293
        
             ##

     

       294
        
       

     

       0
        
       
     

       295
        
             export hardening_unsupported_flags=""

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       296
        
           ''

     

       297
        
       

     

       298
        
           + optionalString hostPlatform.isCygwin ''

     
···

       311
        
           ''

     

       312
        
           + extraBuildCommands;

     

       313
        
       

     

       314
       +
         inherit expand-response-params;

     

       315
        
       

     

       316
        
         # for substitution in utils.sh

     

       317
        
         expandResponseParams = "${expand-response-params}/bin/expand-response-params";

     
···

       322
        
           { description =

     

       323
        
               stdenv.lib.attrByPath ["meta" "description"] "System C compiler" cc_

     

       324
        
               + " (wrapper script)";

     

       0
        
       
     

       0
        
       
     

       325
        
         };

     

       326
        
       }

+2 -6

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

···

       17
        
           PATH="@coreutils_bin@/bin"

     

       18
        
       fi

     

       19
        
       

     

       0
        
       
     

       0
        
       
     

       20
        
       if [ -z "${NIX_@infixSalt@_GNAT_WRAPPER_FLAGS_SET:-}" ]; then

     

       21
        
           source @out@/nix-support/add-flags.sh

     

       22
        
       fi

     

       23
       -
       

     

       24
       -
       source @out@/nix-support/utils.sh

     

       25
        
       

     

       26
        
       

     

       27
        
       # Figure out if linker flags should be passed.  GCC prints annoying

     
···

       36
        
               dontLink=1

     

       37
        
           elif [ "${i:0:1}" != - ]; then

     

       38
        
               nonFlagArgs=1

     

       39
       -
           elif [ "$i" = -m32 ]; then

     

       40
       -
               if [ -e @out@/nix-support/dynamic-linker-m32 ]; then

     

       41
       -
                   NIX_@infixSalt@_LDFLAGS+=" -dynamic-linker $(< @out@/nix-support/dynamic-linker-m32)"

     

       42
       -
               fi

     

       43
        
           fi

     

       44
        
       done

     

       45

···

       17
        
           PATH="@coreutils_bin@/bin"

     

       18
        
       fi

     

       19
        
       

     

       20
       +
       source @out@/nix-support/utils.sh

     

       21
       +
       

     

       22
        
       if [ -z "${NIX_@infixSalt@_GNAT_WRAPPER_FLAGS_SET:-}" ]; then

     

       23
        
           source @out@/nix-support/add-flags.sh

     

       24
        
       fi

     

       0
        
       
     

       0
        
       
     

       25
        
       

     

       26
        
       

     

       27
        
       # Figure out if linker flags should be passed.  GCC prints annoying

     
···

       36
        
               dontLink=1

     

       37
        
           elif [ "${i:0:1}" != - ]; then

     

       38
        
               nonFlagArgs=1

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       39
        
           fi

     

       40
        
       done

     

       41

-29

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

···

       1
       -
       #!@shell@

     

       2
       -
       set -eu -o pipefail

     

       3
       -
       shopt -s nullglob

     

       4
       -
       

     

       5
       -
       if (( "${NIX_DEBUG:-0}" >= 7 )); then

     

       6
       -
           set -x

     

       7
       -
       fi

     

       8
       -
       

     

       9
       -
       declare -a args=("$@")

     

       10
       -
       # I've also tried adding -z direct and -z lazyload, but it gave too many problems with C++ exceptions :'(

     

       11
       -
       # Also made sure libgcc would not be lazy-loaded, as suggested here: https://www.illumos.org/issues/2534#note-3

     

       12
       -
       #   but still no success.

     

       13
       -
       declare -a argsBefore=(-z ignore) argsAfter=()

     

       14
       -
       

     

       15
       -
       # This loop makes sure all -L arguments are before -l arguments, or ld may complain it cannot find a library.

     

       16
       -
       # GNU binutils does not have this problem:

     

       17
       -
       #   http://stackoverflow.com/questions/5817269/does-the-order-of-l-and-l-options-in-the-gnu-linker-matter

     

       18
       -
       while (( $# )); do

     

       19
       -
           case "${args[$i]}" in

     

       20
       -
               -L)   argsBefore+=("$1" "$2"); shift ;;

     

       21
       -
               -L?*) argsBefore+=("$1") ;;

     

       22
       -
               *)    argsAfter+=("$1") ;;

     

       23
       -
           esac

     

       24
       -
           shift

     

       25
       -
       done

     

       26
       -
       

     

       27
       -
       # Trace:

     

       28
       -
       set -x

     

       29
       -
       exec "@ld@" "${argsBefore[@]}" "${argsAfter[@]}"

+3 -3

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

···

       14
        
           PATH="@coreutils_bin@/bin"

     

       15
        
       fi

     

       16
        
       

     

       17
       -
       if [ -z "${NIX_CC_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then

     

       0
        
       
     

       0
        
       
     

       18
        
           source @out@/nix-support/add-flags.sh

     

       19
        
       fi

     

       20
       -
       

     

       21
       -
       source @out@/nix-support/utils.sh

     

       22
        
       

     

       23
        
       

     

       24
        
       # Optionally filter out paths not refering to the store.

···

       14
        
           PATH="@coreutils_bin@/bin"

     

       15
        
       fi

     

       16
        
       

     

       17
       +
       source @out@/nix-support/utils.sh

     

       18
       +
       

     

       19
       +
       if [ -z "${NIX_BINTOOLS_WRAPPER_@infixSalt@_FLAGS_SET:-}" ]; then

     

       20
        
           source @out@/nix-support/add-flags.sh

     

       21
        
       fi

     

       0
        
       
     

       0
        
       
     

       22
        
       

     

       23
        
       

     

       24
        
       # Optionally filter out paths not refering to the store.

+3 -1

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

···

       81
        
       

     

       82
        
           symbolBloatObject=$outputNameLibless-symbol-hack.o

     

       83
        
           if [[ ! -e $symbolBloatObject ]]; then

     

       0
        
       
     

       0
        
       
     

       84
        
               printf '.private_extern _______child_hack_foo\nchild_hack_foo:\n' \

     

       85
       -
                   | @targetPrefix@as -- -o $symbolBloatObject

     

       86
        
           fi

     

       87
        
       

     

       88
        
           # first half of libs

···

       81
        
       

     

       82
        
           symbolBloatObject=$outputNameLibless-symbol-hack.o

     

       83
        
           if [[ ! -e $symbolBloatObject ]]; then

     

       84
       +
               # `-Q` means use GNU Assembler rather than Clang, avoiding an awkward

     

       85
       +
               # dependency cycle.

     

       86
        
               printf '.private_extern _______child_hack_foo\nchild_hack_foo:\n' \

     

       87
       +
                   | @targetPrefix@as -Q -- -o $symbolBloatObject

     

       88
        
           fi

     

       89
        
       

     

       90
        
           # first half of libs

+1 -26

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

···

       74
        
               export NIX_${role}CFLAGS_COMPILE+=" ${ccIncludeFlag:--isystem} $1/include"

     

       75
        
           fi

     

       76
        
       

     

       77
       -
           if [[ -d "$1/lib64" && ! -L "$1/lib64" ]]; then

     

       78
       -
               export NIX_${role}LDFLAGS+=" -L$1/lib64"

     

       79
       -
           fi

     

       80
       -
       

     

       81
       -
           if [[ -d "$1/lib" ]]; then

     

       82
       -
               export NIX_${role}LDFLAGS+=" -L$1/lib"

     

       83
       -
           fi

     

       84
       -
       

     

       85
        
           if [[ -d "$1/Library/Frameworks" ]]; then

     

       86
        
               export NIX_${role}CFLAGS_COMPILE+=" -F$1/Library/Frameworks"

     

       87
        
           fi

     
···

       119
        
       fi

     

       120
        
       

     

       121
        
       # shellcheck disable=SC2157

     

       122
       -
       if [ -n "@binutils_bin@" ]; then

     

       123
       -
           addToSearchPath _PATH @binutils_bin@/bin

     

       124
       -
       fi

     

       125
       -
       

     

       126
       -
       # shellcheck disable=SC2157

     

       127
        
       if [ -n "@libc_bin@" ]; then

     

       128
        
           addToSearchPath _PATH @libc_bin@/bin

     

       129
        
       fi

     
···

       142
        
       export CC${role_post}=@named_cc@

     

       143
        
       export CXX${role_post}=@named_cxx@

     

       144
        
       

     

       145
       -
       for cmd in \

     

       146
       -
           ar as ld nm objcopy objdump readelf ranlib strip strings size windres

     

       147
       -
       do

     

       148
       -
           if

     

       149
       -
               PATH=$_PATH type -p "@targetPrefix@${cmd}" > /dev/null

     

       150
       -
           then

     

       151
       -
               upper_case="$(echo "$cmd" | tr "[:lower:]" "[:upper:]")"

     

       152
       -
               export "${role_pre}${upper_case}=@targetPrefix@${cmd}";

     

       153
       -
               export "${upper_case}${role_post}=@targetPrefix@${cmd}";

     

       154
       -
           fi

     

       155
       -
       done

     

       156
       -
       

     

       157
        
       # No local scope in sourced file

     

       158
       -
       unset -v role_pre role_post cmd upper_case

···

       74
        
               export NIX_${role}CFLAGS_COMPILE+=" ${ccIncludeFlag:--isystem} $1/include"

     

       75
        
           fi

     

       76
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       77
        
           if [[ -d "$1/Library/Frameworks" ]]; then

     

       78
        
               export NIX_${role}CFLAGS_COMPILE+=" -F$1/Library/Frameworks"

     

       79
        
           fi

     
···

       111
        
       fi

     

       112
        
       

     

       113
        
       # shellcheck disable=SC2157

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       114
        
       if [ -n "@libc_bin@" ]; then

     

       115
        
           addToSearchPath _PATH @libc_bin@/bin

     

       116
        
       fi

     
···

       129
        
       export CC${role_post}=@named_cc@

     

       130
        
       export CXX${role_post}=@named_cxx@

     

       131
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       132
        
       # No local scope in sourced file

     

       133
       +
       unset -v role_pre role_post

+32

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

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1
        
       skip () {

     

       2
        
           if (( "${NIX_DEBUG:-0}" >= 1 )); then

     

       3
        
               echo "skipping impure path $1" >&2

···

       1
       +
       mangleVarList() {

     

       2
       +
           local var="$1"

     

       3
       +
           shift

     

       4
       +
           local -a role_infixes=("$@")

     

       5
       +
       

     

       6
       +
           local outputVar="${var/+/_@infixSalt@_}"

     

       7
       +
           declare -gx ${outputVar}+=''

     

       8
       +
           # For each role we serve, we accumulate the input parameters into our own

     

       9
       +
           # cc-wrapper-derivation-specific environment variables.

     

       10
       +
           for infix in "${role_infixes[@]}"; do

     

       11
       +
               local inputVar="${var/+/${infix}}"

     

       12
       +
               if [ -v "$inputVar" ]; then

     

       13
       +
                   export ${outputVar}+="${!outputVar:+ }${!inputVar}"

     

       14
       +
               fi

     

       15
       +
           done

     

       16
       +
       }

     

       17
       +
       

     

       18
       +
       mangleVarBool() {

     

       19
       +
           local var="$1"

     

       20
       +
           shift

     

       21
       +
           local -a role_infixes=("$@")

     

       22
       +
       

     

       23
       +
           local outputVar="${var/+/_@infixSalt@_}"

     

       24
       +
           declare -gxi ${outputVar}+=0

     

       25
       +
           for infix in "${role_infixes[@]}"; do

     

       26
       +
               local inputVar="${var/+/${infix}}"

     

       27
       +
               if [ -v "$inputVar" ]; then

     

       28
       +
                   let "${outputVar} |= ${!inputVar}"

     

       29
       +
               fi

     

       30
       +
           done

     

       31
       +
       }

     

       32
       +
       

     

       33
        
       skip () {

     

       34
        
           if (( "${NIX_DEBUG:-0}" >= 1 )); then

     

       35
        
               echo "skipping impure path $1" >&2

pkgs/build-support/setup-hooks/ld-is-cc-hook.sh

···

       1
       +
       ld-is-cc-hook() {

     

       2
       +
           LD=$CC

     

       3
       +
       }

     

       4
       +
       

     

       5
       +
       preConfigureHooks+=(ld-is-cc-hook)

+3 -3

pkgs/build-support/setup-hooks/separate-debug-info.sh

···

       19
        
               if ! isELF "$i"; then continue; fi

     

       20
        
       

     

       21
        
               # Extract the Build ID. FIXME: there's probably a cleaner way.

     

       22
       -
               local id="$(readelf -n "$i" | sed 's/.*Build ID: \([0-9a-f]*\).*/\1/; t; d')"

     

       23
        
               if [ "${#id}" != 40 ]; then

     

       24
        
                   echo "could not find build ID of $i, skipping" >&2

     

       25
        
                   continue

     
···

       28
        
               # Extract the debug info.

     

       29
        
               header "separating debug info from $i (build ID $id)"

     

       30
        
               mkdir -p "$dst/${id:0:2}"

     

       31
       -
               objcopy --only-keep-debug "$i" "$dst/${id:0:2}/${id:2}.debug"

     

       32
       -
               strip --strip-debug "$i"

     

       33
        
       

     

       34
        
               # Also a create a symlink <original-name>.debug.

     

       35
        
               ln -sfn ".build-id/${id:0:2}/${id:2}.debug" "$dst/../$(basename "$i")"

···

       19
        
               if ! isELF "$i"; then continue; fi

     

       20
        
       

     

       21
        
               # Extract the Build ID. FIXME: there's probably a cleaner way.

     

       22
       +
               local id="$($READELF -n "$i" | sed 's/.*Build ID: \([0-9a-f]*\).*/\1/; t; d')"

     

       23
        
               if [ "${#id}" != 40 ]; then

     

       24
        
                   echo "could not find build ID of $i, skipping" >&2

     

       25
        
                   continue

     
···

       28
        
               # Extract the debug info.

     

       29
        
               header "separating debug info from $i (build ID $id)"

     

       30
        
               mkdir -p "$dst/${id:0:2}"

     

       31
       +
               $OBJCOPY --only-keep-debug "$i" "$dst/${id:0:2}/${id:2}.debug"

     

       32
       +
               $STRIP --strip-debug "$i"

     

       33
        
       

     

       34
        
               # Also a create a symlink <original-name>.debug.

     

       35
        
               ln -sfn ".build-id/${id:0:2}/${id:2}.debug" "$dst/../$(basename "$i")"

+1 -1

pkgs/build-support/setup-hooks/strip.sh

···

       30
        
       

     

       31
        
           if [ -n "${dirs}" ]; then

     

       32
        
               header "stripping (with flags $stripFlags) in$dirs"

     

       33
       -
               find $dirs -type f -print0 | xargs -0 ${xargsFlags:--r} strip $commonStripFlags $stripFlags 2>/dev/null || true

     

       34
        
               stopNest

     

       35
        
           fi

     

       36
        
       }

···

       30
        
       

     

       31
        
           if [ -n "${dirs}" ]; then

     

       32
        
               header "stripping (with flags $stripFlags) in$dirs"

     

       33
       +
               find $dirs -type f -print0 | xargs -0 ${xargsFlags:--r} $STRIP $commonStripFlags $stripFlags 2>/dev/null || true

     

       34
        
               stopNest

     

       35
        
           fi

     

       36
        
       }

+1 -1

pkgs/build-support/setup-hooks/win-dll-link.sh

···

       25
        
           linkCount=0

     

       26
        
           # Iterate over any DLL that we depend on.

     

       27
        
           local dll

     

       28
       -
           for dll in $(objdump -p *.{exe,dll} | sed -n 's/.*DLL Name: \(.*\)/\1/p' | sort -u); do

     

       29
        
               if [ -e "./$dll" ]; then continue; fi

     

       30
        
               # Locate the DLL - it should be an *executable* file on $DLLPATH.

     

       31
        
               local dllPath="$(PATH="$DLLPATH" type -P "$dll")"

···

       25
        
           linkCount=0

     

       26
        
           # Iterate over any DLL that we depend on.

     

       27
        
           local dll

     

       28
       +
           for dll in $($OBJDUMP -p *.{exe,dll} | sed -n 's/.*DLL Name: \(.*\)/\1/p' | sort -u); do

     

       29
        
               if [ -e "./$dll" ]; then continue; fi

     

       30
        
               # Locate the DLL - it should be an *executable* file on $DLLPATH.

     

       31
        
               local dllPath="$(PATH="$DLLPATH" type -P "$dll")"

+2 -2

pkgs/build-support/trivial-builders.nix

···

       95
        
       

     

       96
        
       

     

       97
        
         # Make a package that just contains a setup hook with the given contents.

     

       98
       -
         makeSetupHook = { deps ? [], substitutions ? {} }: script:

     

       99
       -
           runCommand "hook" substitutions

     

       100
        
             (''

     

       101
        
               mkdir -p $out/nix-support

     

       102
        
               cp ${script} $out/nix-support/setup-hook

···

       95
        
       

     

       96
        
       

     

       97
        
         # Make a package that just contains a setup hook with the given contents.

     

       98
       +
         makeSetupHook = { name ? "hook", deps ? [], substitutions ? {} }: script:

     

       99
       +
           runCommand name substitutions

     

       100
        
             (''

     

       101
        
               mkdir -p $out/nix-support

     

       102
        
               cp ${script} $out/nix-support/setup-hook

+3 -1

pkgs/development/compilers/emscripten-fastcomp/default.nix

···

       1
       -
       { newScope, stdenv, wrapCC, wrapCCWith, symlinkJoin }:

     

       2
        
       let

     

       3
        
         callPackage = newScope (self // {inherit stdenv;});

     

       4
        
       

     
···

       6
        
           emscriptenfastcomp-unwrapped = callPackage ./emscripten-fastcomp.nix {};

     

       7
        
           emscriptenfastcomp-wrapped = wrapCCWith {

     

       8
        
             cc = self.emscriptenfastcomp-unwrapped;

     

       0
        
       
     

       0
        
       
     

       9
        
             libc = stdenv.cc.libc;

     

       10
        
             extraBuildCommands = ''

     

       11
        
               # hardening flags break WASM support

···

       1
       +
       { newScope, stdenv, binutils-raw, wrapCCWith, symlinkJoin }:

     

       2
        
       let

     

       3
        
         callPackage = newScope (self // {inherit stdenv;});

     

       4
        
       

     
···

       6
        
           emscriptenfastcomp-unwrapped = callPackage ./emscripten-fastcomp.nix {};

     

       7
        
           emscriptenfastcomp-wrapped = wrapCCWith {

     

       8
        
             cc = self.emscriptenfastcomp-unwrapped;

     

       9
       +
             # Never want Apple's cctools for WASM target

     

       10
       +
             bintools = binutils-raw;

     

       11
        
             libc = stdenv.cc.libc;

     

       12
        
             extraBuildCommands = ''

     

       13
        
               # hardening flags break WASM support

pkgs/development/compilers/gcc/4.5/default.nix

···

       356
        
           dontStrip = true;

     

       357
        
         };

     

       358
        
       

     

       0
        
       
     

       359
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       360
        
       

     

       361
        
         # Needed for the cross compilation to work

···

       356
        
           dontStrip = true;

     

       357
        
         };

     

       358
        
       

     

       359
       +
         NIX_BUILD_BINTOOLS = buildPackages.stdenv.cc.bintools;

     

       360
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       361
        
       

     

       362
        
         # Needed for the cross compilation to work

pkgs/development/compilers/gcc/4.8/default.nix

···

       444
        
           buildFlags = "";

     

       445
        
         };

     

       446
        
       

     

       0
        
       
     

       447
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       448
        
       

     

       449
        
         # Needed for the cross compilation to work

···

       444
        
           buildFlags = "";

     

       445
        
         };

     

       446
        
       

     

       447
       +
         NIX_BUILD_BINTOOLS = buildPackages.stdenv.cc.bintools;

     

       448
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       449
        
       

     

       450
        
         # Needed for the cross compilation to work

pkgs/development/compilers/gcc/4.9/default.nix

···

       442
        
           buildFlags = "";

     

       443
        
         };

     

       444
        
       

     

       0
        
       
     

       445
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       446
        
       

     

       447
        
         # Needed for the cross compilation to work

···

       442
        
           buildFlags = "";

     

       443
        
         };

     

       444
        
       

     

       445
       +
         NIX_BUILD_BINTOOLS = buildPackages.stdenv.cc.bintools;

     

       446
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       447
        
       

     

       448
        
         # Needed for the cross compilation to work

pkgs/development/compilers/gcc/5/default.nix

···

       451
        
           buildFlags = "";

     

       452
        
         };

     

       453
        
       

     

       0
        
       
     

       454
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       455
        
       

     

       456
        
         # Needed for the cross compilation to work

···

       451
        
           buildFlags = "";

     

       452
        
         };

     

       453
        
       

     

       454
       +
         NIX_BUILD_BINTOOLS = buildPackages.stdenv.cc.bintools;

     

       455
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       456
        
       

     

       457
        
         # Needed for the cross compilation to work

pkgs/development/compilers/gcc/6/default.nix

···

       452
        
           buildFlags = "";

     

       453
        
         };

     

       454
        
       

     

       0
        
       
     

       455
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       456
        
       

     

       457
        
         # Needed for the cross compilation to work

···

       452
        
           buildFlags = "";

     

       453
        
         };

     

       454
        
       

     

       455
       +
         NIX_BUILD_BINTOOLS = buildPackages.stdenv.cc.bintools;

     

       456
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       457
        
       

     

       458
        
         # Needed for the cross compilation to work

pkgs/development/compilers/gcc/7/default.nix

···

       446
        
           buildFlags = "";

     

       447
        
         };

     

       448
        
       

     

       0
        
       
     

       449
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       450
        
       

     

       451
        
         # Needed for the cross compilation to work

···

       446
        
           buildFlags = "";

     

       447
        
         };

     

       448
        
       

     

       449
       +
         NIX_BUILD_BINTOOLS = buildPackages.stdenv.cc.bintools;

     

       450
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       451
        
       

     

       452
        
         # Needed for the cross compilation to work

+35 -20

pkgs/development/compilers/gcc/builder.sh

···

       12
        
       if test "$staticCompiler" = "1"; then

     

       13
        
           EXTRA_LDFLAGS="-static"

     

       14
        
       else

     

       15
       -
           EXTRA_LDFLAGS="-Wl,-rpath,$lib/lib"

     

       16
        
       fi

     

       17
        
       

     

       18
        
       

     
···

       28
        
               EXTRA_BUILD_FLAGS EXTRA_FLAGS EXTRA_TARGET_FLAGS \

     

       29
        
               EXTRA_BUILD_LDFLAGS EXTRA_TARGET_LDFLAGS

     

       30
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
           for pre in 'BUILD_' ''; do

     

       32
        
               curCC="NIX_${pre}CC"

     

       33
        
               curFIXINC="NIX_${pre}FIXINC_DUMMY"

     

       34
        
       

     

       35
       -
               declare -a extraFlags=() extraLDFlags=()

     

       36
        
               if [[ -e "${!curCC}/nix-support/orig-libc" ]]; then

     

       37
       -
                   # Figure out what extra flags to pass to the gcc compilers being

     

       38
       -
                   # generated to make sure that they use our glibc.

     

       39
       -
                   extraFlags=($(cat "${!curCC}/nix-support/libc-cflags"))

     

       40
       -
                   extraLDFlags=($(cat "${!curCC}/nix-support/libc-ldflags") $(cat "${!curCC}/nix-support/libc-ldflags-before" || true))

     

       41
        
       

     

       42
       -
                   # The path to the Glibc binaries such as `crti.o'.

     

       43
       -
                   glibc_libdir="$(cat "${!curCC}/nix-support/orig-libc")/lib"

     

       44
       -
                   glibc_devdir="$(cat "${!curCC}/nix-support/orig-libc-dev")"

     

       45
        
       

     

       46
        
                   # Use *real* header files, otherwise a limits.h is generated that

     

       47
       -
                   # does not include Glibc's limits.h (notably missing SSIZE_MAX,

     

       48
        
                   # which breaks the build).

     

       49
       -
                   declare NIX_${pre}FIXINC_DUMMY="$glibc_devdir/include"

     

       50
        
               else

     

       51
        
                   # Hack: support impure environments.

     

       52
        
                   extraFlags=("-isystem" "/usr/include")

     

       53
       -
                   extraLDFlags=("-L/usr/lib64" "-L/usr/lib")

     

       54
       -
                   glibc_libdir="/usr/lib"

     

       55
        
                   declare NIX_${pre}FIXINC_DUMMY=/usr/include

     

       56
        
               fi

     

       57
        
       

     

       58
       -
               extraFlags=("-I${!curFIXINC}"

     

       59
       -
                           "${extraFlags[@]}")

     

       60
       -
               extraLDFlags=("-L$glibc_libdir" "-rpath" "$glibc_libdir"

     

       61
       -
                             "${extraLDFlags[@]}")

     

       62
        
       

     

       63
        
               # BOOT_CFLAGS defaults to `-g -O2'; since we override it below, make

     

       64
        
               # sure to explictly add them so that files compiled with the bootstrap

     
···

       72
        
               fi

     

       73
        
       

     

       74
        
               declare EXTRA_${pre}FLAGS="${extraFlags[*]}"

     

       75
       -
               for i in "${extraLDFlags[@]}"; do

     

       76
       -
                   declare EXTRA_${pre}LDFLAGS+=" -Wl,$i"

     

       77
       -
               done

     

       78
        
           done

     

       79
        
       

     

       80
        
           if test -z "${targetConfig-}"; then

···

       12
        
       if test "$staticCompiler" = "1"; then

     

       13
        
           EXTRA_LDFLAGS="-static"

     

       14
        
       else

     

       15
       +
           EXTRA_LDFLAGS="-Wl,-rpath,${!outputLib}/lib"

     

       16
        
       fi

     

       17
        
       

     

       18
        
       

     
···

       28
        
               EXTRA_BUILD_FLAGS EXTRA_FLAGS EXTRA_TARGET_FLAGS \

     

       29
        
               EXTRA_BUILD_LDFLAGS EXTRA_TARGET_LDFLAGS

     

       30
        
       

     

       31
       +
           # Extract flags from Bintools Wrappers

     

       32
       +
           for pre in 'BUILD_' ''; do

     

       33
       +
               curBintools="NIX_${pre}BINTOOLS"

     

       34
       +
       

     

       35
       +
               declare -a extraLDFlags=()

     

       36
       +
               if [[ -e "${!curBintools}/nix-support/orig-libc" ]]; then

     

       37
       +
                   # Figure out what extra flags when linking to pass to the gcc

     

       38
       +
                   # compilers being generated to make sure that they use our libc.

     

       39
       +
                   extraLDFlags=($(< "${!curBintools}/nix-support/libc-ldflags") $(< "${!curBintools}/nix-support/libc-ldflags-before" || true))

     

       40
       +
       

     

       41
       +
                   # The path to the Libc binaries such as `crti.o'.

     

       42
       +
                   libc_libdir="$(< "${!curBintools}/nix-support/orig-libc")/lib"

     

       43
       +
               else

     

       44
       +
                   # Hack: support impure environments.

     

       45
       +
                   extraLDFlags=("-L/usr/lib64" "-L/usr/lib")

     

       46
       +
                   libc_libdir="/usr/lib"

     

       47
       +
               fi

     

       48
       +
               extraLDFlags=("-L$libc_libdir" "-rpath" "$libc_libdir"

     

       49
       +
                             "${extraLDFlags[@]}")

     

       50
       +
               for i in "${extraLDFlags[@]}"; do

     

       51
       +
                   declare EXTRA_${pre}LDFLAGS+=" -Wl,$i"

     

       52
       +
               done

     

       53
       +
           done

     

       54
       +
       

     

       55
       +
           # Extract flags from CC Wrappers

     

       56
        
           for pre in 'BUILD_' ''; do

     

       57
        
               curCC="NIX_${pre}CC"

     

       58
        
               curFIXINC="NIX_${pre}FIXINC_DUMMY"

     

       59
        
       

     

       60
       +
               declare -a extraFlags=()

     

       61
        
               if [[ -e "${!curCC}/nix-support/orig-libc" ]]; then

     

       62
       +
                   # Figure out what extra compiling flags to pass to the gcc compilers

     

       63
       +
                   # being generated to make sure that they use our libc.

     

       64
       +
                   extraFlags=($(< "${!curCC}/nix-support/libc-cflags"))

     

       0
        
       
     

       65
        
       

     

       66
       +
                   # The path to the Libc headers

     

       67
       +
                   libc_devdir="$(< "${!curCC}/nix-support/orig-libc-dev")"

     

       0
        
       
     

       68
        
       

     

       69
        
                   # Use *real* header files, otherwise a limits.h is generated that

     

       70
       +
                   # does not include Libc's limits.h (notably missing SSIZE_MAX,

     

       71
        
                   # which breaks the build).

     

       72
       +
                   declare NIX_${pre}FIXINC_DUMMY="$libc_devdir/include"

     

       73
        
               else

     

       74
        
                   # Hack: support impure environments.

     

       75
        
                   extraFlags=("-isystem" "/usr/include")

     

       0
        
       
     

       0
        
       
     

       76
        
                   declare NIX_${pre}FIXINC_DUMMY=/usr/include

     

       77
        
               fi

     

       78
        
       

     

       79
       +
               extraFlags=("-I${!curFIXINC}" "${extraFlags[@]}")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
       

     

       81
        
               # BOOT_CFLAGS defaults to `-g -O2'; since we override it below, make

     

       82
        
               # sure to explictly add them so that files compiled with the bootstrap

     
···

       90
        
               fi

     

       91
        
       

     

       92
        
               declare EXTRA_${pre}FLAGS="${extraFlags[*]}"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       93
        
           done

     

       94
        
       

     

       95
        
           if test -z "${targetConfig-}"; then

pkgs/development/compilers/gcc/snapshot/default.nix

···

       433
        
           buildFlags = "";

     

       434
        
         };

     

       435
        
       

     

       0
        
       
     

       436
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       437
        
       

     

       438
        
         # Needed for the cross compilation to work

···

       433
        
           buildFlags = "";

     

       434
        
         };

     

       435
        
       

     

       436
       +
         NIX_BUILD_BINTOOLS = buildPackages.stdenv.cc.bintools;

     

       437
        
         NIX_BUILD_CC = buildPackages.stdenv.cc;

     

       438
        
       

     

       439
        
         # Needed for the cross compilation to work

+2 -2

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

···

       30
        
           libstdcxxClang = ccWrapperFun {

     

       31
        
             cc = self.clang-unwrapped;

     

       32
        
             /* FIXME is this right? */

     

       33
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       34
        
             extraPackages = [ libstdcxxHook ];

     

       35
        
           };

     

       36
        
       

     

       37
        
           libcxxClang = ccWrapperFun {

     

       38
        
             cc = self.clang-unwrapped;

     

       39
        
             /* FIXME is this right? */

     

       40
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       41
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       42
        
           };

     

       43

···

       30
        
           libstdcxxClang = ccWrapperFun {

     

       31
        
             cc = self.clang-unwrapped;

     

       32
        
             /* FIXME is this right? */

     

       33
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       34
        
             extraPackages = [ libstdcxxHook ];

     

       35
        
           };

     

       36
        
       

     

       37
        
           libcxxClang = ccWrapperFun {

     

       38
        
             cc = self.clang-unwrapped;

     

       39
        
             /* FIXME is this right? */

     

       40
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       41
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       42
        
           };

     

       43

+2 -2

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

···

       27
        
           libstdcxxClang = ccWrapperFun {

     

       28
        
             cc = self.clang-unwrapped;

     

       29
        
             /* FIXME is this right? */

     

       30
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       31
        
             extraPackages = [ libstdcxxHook ];

     

       32
        
           };

     

       33
        
       

     

       34
        
           libcxxClang = ccWrapperFun {

     

       35
        
             cc = self.clang-unwrapped;

     

       36
        
             /* FIXME is this right? */

     

       37
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       38
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       39
        
           };

     

       40

···

       27
        
           libstdcxxClang = ccWrapperFun {

     

       28
        
             cc = self.clang-unwrapped;

     

       29
        
             /* FIXME is this right? */

     

       30
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       31
        
             extraPackages = [ libstdcxxHook ];

     

       32
        
           };

     

       33
        
       

     

       34
        
           libcxxClang = ccWrapperFun {

     

       35
        
             cc = self.clang-unwrapped;

     

       36
        
             /* FIXME is this right? */

     

       37
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       38
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       39
        
           };

     

       40

+2 -2

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

···

       27
        
           libstdcxxClang = ccWrapperFun {

     

       28
        
             cc = self.clang-unwrapped;

     

       29
        
             /* FIXME is this right? */

     

       30
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       31
        
             extraPackages = [ libstdcxxHook ];

     

       32
        
           };

     

       33
        
       

     

       34
        
           libcxxClang = ccWrapperFun {

     

       35
        
             cc = self.clang-unwrapped;

     

       36
        
             /* FIXME is this right? */

     

       37
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       38
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       39
        
           };

     

       40

···

       27
        
           libstdcxxClang = ccWrapperFun {

     

       28
        
             cc = self.clang-unwrapped;

     

       29
        
             /* FIXME is this right? */

     

       30
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       31
        
             extraPackages = [ libstdcxxHook ];

     

       32
        
           };

     

       33
        
       

     

       34
        
           libcxxClang = ccWrapperFun {

     

       35
        
             cc = self.clang-unwrapped;

     

       36
        
             /* FIXME is this right? */

     

       37
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       38
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       39
        
           };

     

       40

+2 -2

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

···

       42
        
           libstdcxxClang = ccWrapperFun {

     

       43
        
             cc = self.clang-unwrapped;

     

       44
        
             /* FIXME is this right? */

     

       45
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       46
        
             extraPackages = [ libstdcxxHook ];

     

       47
        
           };

     

       48
        
       

     

       49
        
           libcxxClang = ccWrapperFun {

     

       50
        
             cc = self.clang-unwrapped;

     

       51
        
             /* FIXME is this right? */

     

       52
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       53
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       54
        
           };

     

       55

···

       42
        
           libstdcxxClang = ccWrapperFun {

     

       43
        
             cc = self.clang-unwrapped;

     

       44
        
             /* FIXME is this right? */

     

       45
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       46
        
             extraPackages = [ libstdcxxHook ];

     

       47
        
           };

     

       48
        
       

     

       49
        
           libcxxClang = ccWrapperFun {

     

       50
        
             cc = self.clang-unwrapped;

     

       51
        
             /* FIXME is this right? */

     

       52
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       53
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       54
        
           };

     

       55

+2 -2

pkgs/development/compilers/llvm/5/default.nix

···

       42
        
           libstdcxxClang = ccWrapperFun {

     

       43
        
             cc = self.clang-unwrapped;

     

       44
        
             /* FIXME is this right? */

     

       45
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       46
        
             extraPackages = [ libstdcxxHook ];

     

       47
        
           };

     

       48
        
       

     

       49
        
           libcxxClang = ccWrapperFun {

     

       50
        
             cc = self.clang-unwrapped;

     

       51
        
             /* FIXME is this right? */

     

       52
       -
             inherit (stdenv.cc) libc nativeTools nativeLibc;

     

       53
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       54
        
           };

     

       55

···

       42
        
           libstdcxxClang = ccWrapperFun {

     

       43
        
             cc = self.clang-unwrapped;

     

       44
        
             /* FIXME is this right? */

     

       45
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       46
        
             extraPackages = [ libstdcxxHook ];

     

       47
        
           };

     

       48
        
       

     

       49
        
           libcxxClang = ccWrapperFun {

     

       50
        
             cc = self.clang-unwrapped;

     

       51
        
             /* FIXME is this right? */

     

       52
       +
             inherit (stdenv.cc) bintools libc nativeTools nativeLibc;

     

       53
        
             extraPackages = [ self.libcxx self.libcxxabi ];

     

       54
        
           };

     

       55

+48

pkgs/development/compilers/llvm/multi.nix

···

       1
       +
       { runCommand,

     

       2
       +
       clang,

     

       3
       +
       gcc64,

     

       4
       +
       gcc32,

     

       5
       +
       glibc_multi

     

       6
       +
       }:

     

       7
       +
       

     

       8
       +
       let

     

       9
       +
         combine = basegcc: runCommand "combine-gcc-libc" {} ''

     

       10
       +
           mkdir -p $out

     

       11
       +
           cp -r ${basegcc.cc}/lib $out/lib

     

       12
       +
       

     

       13
       +
           chmod u+rw -R $out/lib

     

       14
       +
           cp -r ${basegcc.libc}/lib/* $(ls -d $out/lib/gcc/*/*)

     

       15
       +
         '';

     

       16
       +
         gcc_multi_sysroot = runCommand "gcc-multi-sysroot" {} ''

     

       17
       +
           mkdir -p $out/lib/gcc

     

       18
       +
       

     

       19
       +
           ln -s ${combine gcc64}/lib/gcc/* $out/lib/gcc/

     

       20
       +
           ln -s ${combine gcc32}/lib/gcc/* $out/lib/gcc/

     

       21
       +
           # XXX: This shouldn't be needed, clang just doesn't look for "i686-unknown"

     

       22
       +
           ln -s $out/lib/gcc/i686-unknown-linux-gnu $out/lib/gcc/i686-pc-linux-gnu

     

       23
       +
       

     

       24
       +
       

     

       25
       +
           # includes

     

       26
       +
           ln -s ${glibc_multi.dev}/include $out/

     

       27
       +
       

     

       28
       +
           # dynamic linkers

     

       29
       +
           mkdir -p $out/lib/32

     

       30
       +
           ln -s ${glibc_multi.out}/lib/ld-linux* $out/lib

     

       31
       +
           ln -s ${glibc_multi.out}/lib/32/ld-linux* $out/lib/32/

     

       32
       +
         '';

     

       33
       +
       

     

       34
       +
         clangMulti = clang.override {

     

       35
       +
           # Only used for providing expected structure re:dynamic linkers, AFAIK

     

       36
       +
           # Most of the magic is done by setting the --gcc-toolchain option below

     

       37
       +
           libc = gcc_multi_sysroot;

     

       38
       +
       

     

       39
       +
           bintools = clang.bintools.override {

     

       40
       +
             libc = gcc_multi_sysroot;

     

       41
       +
           };

     

       42
       +
       

     

       43
       +
           extraBuildCommands = ''

     

       44
       +
             sed -e '$a --gcc-toolchain=${gcc_multi_sysroot}' -i $out/nix-support/libc-cflags

     

       45
       +
           '';

     

       46
       +
         };

     

       47
       +
       

     

       48
       +
       in clangMulti

+2 -2

pkgs/development/interpreters/python/build-python-package.nix

···

       7
        
       , setuptools

     

       8
        
       , unzip

     

       9
        
       , ensureNewerSourcesHook

     

       10
       -
       , pythonModule

     

       11
        
       , namePrefix

     

       12
        
       , bootstrapped-pip

     

       13
        
       , flit

     
···

       19
        
         wheel-specific = import ./build-python-package-wheel.nix { };

     

       20
        
         common = import ./build-python-package-common.nix { inherit python bootstrapped-pip; };

     

       21
        
         mkPythonDerivation = import ./mk-python-derivation.nix {

     

       22
       -
           inherit lib python wrapPython setuptools unzip ensureNewerSourcesHook pythonModule namePrefix;

     

       23
        
         };

     

       24
        
       in

     

       25

···

       7
        
       , setuptools

     

       8
        
       , unzip

     

       9
        
       , ensureNewerSourcesHook

     

       10
       +
       , toPythonModule

     

       11
        
       , namePrefix

     

       12
        
       , bootstrapped-pip

     

       13
        
       , flit

     
···

       19
        
         wheel-specific = import ./build-python-package-wheel.nix { };

     

       20
        
         common = import ./build-python-package-common.nix { inherit python bootstrapped-pip; };

     

       21
        
         mkPythonDerivation = import ./mk-python-derivation.nix {

     

       22
       +
           inherit lib python wrapPython setuptools unzip ensureNewerSourcesHook toPythonModule namePrefix;

     

       23
        
         };

     

       24
        
       in

     

       25

+14 -8

pkgs/development/interpreters/python/mk-python-derivation.nix

···

       7
        
       , unzip

     

       8
        
       , ensureNewerSourcesHook

     

       9
        
       # Whether the derivation provides a Python module or not.

     

       10
       -
       , pythonModule

     

       11
        
       , namePrefix

     

       12
        
       }:

     

       13
        
       

     
···

       40
        
       # Skip wrapping of python programs altogether

     

       41
        
       , dontWrapPythonPrograms ? false

     

       42
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       43
        
       , meta ? {}

     

       44
        
       

     

       45
        
       , passthru ? {}

     
···

       54
        
       then throw "${name} not supported for interpreter ${python.executable}"

     

       55
        
       else

     

       56
        
       

     

       57
       -
       python.stdenv.mkDerivation (builtins.removeAttrs attrs [

     

       58
        
           "disabled" "checkInputs" "doCheck" "doInstallCheck" "dontWrapPythonPrograms" "catchConflicts"

     

       59
        
         ] // {

     

       60
        
       

     
···

       77
        
       

     

       78
        
         postFixup = lib.optionalString (!dontWrapPythonPrograms) ''

     

       79
        
           wrapPythonPrograms

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
         '' + lib.optionalString catchConflicts ''

     

       81
        
           # Check if we have two packages with the same name in the closure and fail.

     

       82
        
           # If this happens, something went wrong with the dependencies specs.

     
···

       84
        
           ${python.interpreter} ${./catch_conflicts}/catch_conflicts.py

     

       85
        
         '' + attrs.postFixup or '''';

     

       86
        
       

     

       87
       -
         passthru = {

     

       88
       -
           inherit python; # The python interpreter

     

       89
       -
           inherit pythonModule;

     

       90
       -
         } // passthru;

     

       91
       -
       

     

       92
        
         meta = {

     

       93
        
           # default to python's platforms

     

       94
        
           platforms = python.meta.platforms;

     

       95
        
           isBuildPythonPackage = python.meta.platforms;

     

       96
        
         } // meta;

     

       97
       -
       })

···

       7
        
       , unzip

     

       8
        
       , ensureNewerSourcesHook

     

       9
        
       # Whether the derivation provides a Python module or not.

     

       10
       +
       , toPythonModule

     

       11
        
       , namePrefix

     

       12
        
       }:

     

       13
        
       

     
···

       40
        
       # Skip wrapping of python programs altogether

     

       41
        
       , dontWrapPythonPrograms ? false

     

       42
        
       

     

       43
       +
       # Remove bytecode from bin folder.

     

       44
       +
       # When a Python script has the extension `.py`, bytecode is generated

     

       45
       +
       # Typically, executables in bin have no extension, so no bytecode is generated.

     

       46
       +
       # However, some packages do provide executables with extensions, and thus bytecode is generated.

     

       47
       +
       , removeBinBytecode ? true

     

       48
       +
       

     

       49
        
       , meta ? {}

     

       50
        
       

     

       51
        
       , passthru ? {}

     
···

       60
        
       then throw "${name} not supported for interpreter ${python.executable}"

     

       61
        
       else

     

       62
        
       

     

       63
       +
       toPythonModule (python.stdenv.mkDerivation (builtins.removeAttrs attrs [

     

       64
        
           "disabled" "checkInputs" "doCheck" "doInstallCheck" "dontWrapPythonPrograms" "catchConflicts"

     

       65
        
         ] // {

     

       66
        
       

     
···

       83
        
       

     

       84
        
         postFixup = lib.optionalString (!dontWrapPythonPrograms) ''

     

       85
        
           wrapPythonPrograms

     

       86
       +
         '' + lib.optionalString removeBinBytecode ''

     

       87
       +
           if [ -d "$out/bin" ]; then

     

       88
       +
             rm -rf "$out/bin/__pycache__"                 # Python 3

     

       89
       +
             find "$out/bin" -type f -name "*.pyc" -delete # Python 2

     

       90
       +
           fi

     

       91
        
         '' + lib.optionalString catchConflicts ''

     

       92
        
           # Check if we have two packages with the same name in the closure and fail.

     

       93
        
           # If this happens, something went wrong with the dependencies specs.

     
···

       95
        
           ${python.interpreter} ${./catch_conflicts}/catch_conflicts.py

     

       96
        
         '' + attrs.postFixup or '''';

     

       97
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       98
        
         meta = {

     

       99
        
           # default to python's platforms

     

       100
        
           platforms = python.meta.platforms;

     

       101
        
           isBuildPythonPackage = python.meta.platforms;

     

       102
        
         } // meta;

     

       103
       +
       }))

pkgs/development/libraries/boost/1.65.nix

···

       9
        
           sha256 = "9807a5d16566c57fd74fb522764e0b134a8bbe6b6e8967b83afefd30dcd3be81";

     

       10
        
         };

     

       11
        
       

     

       0
        
       
     

       0
        
       
     

       12
        
       })

···

       9
        
           sha256 = "9807a5d16566c57fd74fb522764e0b134a8bbe6b6e8967b83afefd30dcd3be81";

     

       10
        
         };

     

       11
        
       

     

       12
       +
         enableNumpy = true;

     

       13
       +
       

     

       14
        
       })

+2 -2

pkgs/development/libraries/boost/generic.nix

···

       10
        
       , enablePIC ? false

     

       11
        
       , enableExceptions ? false

     

       12
        
       , enablePython ? hostPlatform == buildPlatform

     

       13
       -
       , enableNumpy ? false, numpy ? null

     

       14
        
       , taggedLayout ? ((enableRelease && enableDebug) || (enableSingleThreaded && enableMultiThreaded) || (enableShared && enableStatic))

     

       15
        
       , patches ? null

     

       16
        
       , mpi ? null

     
···

       156
        
           ++ optional (hostPlatform == buildPlatform) icu

     

       157
        
           ++ optional stdenv.isDarwin fixDarwinDylibNames

     

       158
        
           ++ optional enablePython python

     

       159
       -
           ++ optional enableNumpy numpy;

     

       160
        
       

     

       161
        
         configureScript = "./bootstrap.sh";

     

       162
        
         configureFlags = commonConfigureFlags

···

       10
        
       , enablePIC ? false

     

       11
        
       , enableExceptions ? false

     

       12
        
       , enablePython ? hostPlatform == buildPlatform

     

       13
       +
       , enableNumpy ? false

     

       14
        
       , taggedLayout ? ((enableRelease && enableDebug) || (enableSingleThreaded && enableMultiThreaded) || (enableShared && enableStatic))

     

       15
        
       , patches ? null

     

       16
        
       , mpi ? null

     
···

       156
        
           ++ optional (hostPlatform == buildPlatform) icu

     

       157
        
           ++ optional stdenv.isDarwin fixDarwinDylibNames

     

       158
        
           ++ optional enablePython python

     

       159
       +
           ++ optional enableNumpy python.pkgs.numpy;

     

       160
        
       

     

       161
        
         configureScript = "./bootstrap.sh";

     

       162
        
         configureFlags = commonConfigureFlags

+11 -7

pkgs/development/libraries/fribidi/default.nix

···

       1
       -
       {stdenv, fetchurl}:

     

       2
        
       

     

       3
        
       stdenv.mkDerivation rec {

     

       4
        
         name = "fribidi-${version}";

     

       5
        
         version = "0.19.7";

     

       6
        
       

     

       7
       -
         src = fetchurl {

     

       8
       -
           url = "http://fribidi.org/download/${name}.tar.bz2";

     

       9
       -
           sha256 = "13jsb5qadlhsaxkbrb49nqslmbh904vvzhsm5mm2ghmv29i2l8h8";

     

       0
        
       
     

       0
        
       
     

       10
        
         };

     

       11
        
       

     

       12
       -
         hardeningDisable = [ "format" ];

     

       0
        
       
     

       0
        
       
     

       13
        
       

     

       14
        
         outputs = [ "out" "devdoc" ];

     

       15
        
       

     

       16
        
         meta = with stdenv.lib; {

     

       17
       -
           homepage = http://fribidi.org/;

     

       18
        
           description = "GNU implementation of the Unicode Bidirectional Algorithm (bidi)";

     

       19
       -
           license = licenses.gpl2;

     

       20
        
           platforms = platforms.unix;

     

       21
        
         };

     

       22
        
       }

···

       1
       +
       { stdenv, fetchFromGitHub, autoreconfHook, pkgconfig }:

     

       2
        
       

     

       3
        
       stdenv.mkDerivation rec {

     

       4
        
         name = "fribidi-${version}";

     

       5
        
         version = "0.19.7";

     

       6
        
       

     

       7
       +
         src = fetchFromGitHub {

     

       8
       +
           owner = "fribidi";

     

       9
       +
           repo = "fribidi";

     

       10
       +
           rev = version;

     

       11
       +
           sha256 = "10q5jfch5qzrj2w4fbkr086ank66plx8hp7ra9a01irj80pbk96d";

     

       12
        
         };

     

       13
        
       

     

       14
       +
         nativeBuildInputs = [ autoreconfHook pkgconfig ];

     

       15
       +
       

     

       16
       +
         # Configure script checks for glib, but it is only used for tests.

     

       17
        
       

     

       18
        
         outputs = [ "out" "devdoc" ];

     

       19
        
       

     

       20
        
         meta = with stdenv.lib; {

     

       21
       +
           homepage = https://github.com/fribidi/fribidi;

     

       22
        
           description = "GNU implementation of the Unicode Bidirectional Algorithm (bidi)";

     

       23
       +
           license = licenses.lgpl21;

     

       24
        
           platforms = platforms.unix;

     

       25
        
         };

     

       26
        
       }

+2 -2

pkgs/development/libraries/gstreamer/vaapi/default.nix

···

       5
        
       

     

       6
        
       stdenv.mkDerivation rec {

     

       7
        
         name = "gst-vaapi-${version}";

     

       8
       -
         version = "1.12.3";

     

       9
        
       

     

       10
        
         src = fetchurl {

     

       11
        
           url = "${meta.homepage}/src/gstreamer-vaapi/gstreamer-vaapi-${version}.tar.xz";

     

       12
       -
           sha256 = "0kbl2c4zv004qwhm9mc0jlhz2pc3dqrng2vwj68a81lnzpcazkgl";

     

       13
        
         };

     

       14
        
       

     

       15
        
         outputs = [ "out" "dev" ];

···

       5
        
       

     

       6
        
       stdenv.mkDerivation rec {

     

       7
        
         name = "gst-vaapi-${version}";

     

       8
       +
         version = "1.12.4";

     

       9
        
       

     

       10
        
         src = fetchurl {

     

       11
        
           url = "${meta.homepage}/src/gstreamer-vaapi/gstreamer-vaapi-${version}.tar.xz";

     

       12
       +
           sha256 = "1jg9nvc8000yi2bcl3wn2yh2hwl7yvlwldj6778w8c0z5qj7fb8w";

     

       13
        
         };

     

       14
        
       

     

       15
        
         outputs = [ "out" "dev" ];

+2 -2

pkgs/development/libraries/libbfd/default.nix

···

       5
        
       

     

       6
        
       stdenv.mkDerivation rec {

     

       7
        
         name = "libbfd-${version}";

     

       8
       -
         inherit (binutils-raw) version src;

     

       9
        
       

     

       10
        
         outputs = [ "out" "dev" ];

     

       11
        
       

     

       12
       -
         patches = binutils-raw.patches ++ [

     

       13
        
           ../../tools/misc/binutils/build-components-separately.patch

     

       14
        
         ];

     

       15

···

       5
        
       

     

       6
        
       stdenv.mkDerivation rec {

     

       7
        
         name = "libbfd-${version}";

     

       8
       +
         inherit (binutils-raw.bintools) version src;

     

       9
        
       

     

       10
        
         outputs = [ "out" "dev" ];

     

       11
        
       

     

       12
       +
         patches = binutils-raw.bintools.patches ++ [

     

       13
        
           ../../tools/misc/binutils/build-components-separately.patch

     

       14
        
         ];

     

       15

+2 -2

pkgs/development/libraries/libjpeg-turbo/default.nix

···

       4
        
       

     

       5
        
       stdenv.mkDerivation rec {

     

       6
        
         name = "libjpeg-turbo-${version}";

     

       7
       -
         version = "1.5.2";

     

       8
        
       

     

       9
        
         src = fetchurl {

     

       10
        
           url = "mirror://sourceforge/libjpeg-turbo/${name}.tar.gz";

     

       11
       -
           sha256 = "0a5m0psfp5952y5vrcs0nbdz1y9wqzg2ms0xwrx752034wxr964h";

     

       12
        
         }; # github releases still need autotools, surprisingly

     

       13
        
       

     

       14
        
         patches =

···

       4
        
       

     

       5
        
       stdenv.mkDerivation rec {

     

       6
        
         name = "libjpeg-turbo-${version}";

     

       7
       +
         version = "1.5.3";

     

       8
        
       

     

       9
        
         src = fetchurl {

     

       10
        
           url = "mirror://sourceforge/libjpeg-turbo/${name}.tar.gz";

     

       11
       +
           sha256 = "08r5b5mywwrxv4axvq80dm31cklz81grczlzlxr2xqa6pgi90j5j";

     

       12
        
         }; # github releases still need autotools, surprisingly

     

       13
        
       

     

       14
        
         patches =

+2 -2

pkgs/development/libraries/libopcodes/default.nix

···

       5
        
       

     

       6
        
       stdenv.mkDerivation rec {

     

       7
        
         name = "libopcodes-${version}";

     

       8
       -
         inherit (binutils-raw) version src;

     

       9
        
       

     

       10
        
         outputs = [ "out" "dev" ];

     

       11
        
       

     

       12
       -
         patches = binutils-raw.patches ++ [

     

       13
        
           ../../tools/misc/binutils/build-components-separately.patch

     

       14
        
         ];

     

       15

···

       5
        
       

     

       6
        
       stdenv.mkDerivation rec {

     

       7
        
         name = "libopcodes-${version}";

     

       8
       +
         inherit (binutils-raw.bintools) version src;

     

       9
        
       

     

       10
        
         outputs = [ "out" "dev" ];

     

       11
        
       

     

       12
       +
         patches = binutils-raw.bintools.patches ++ [

     

       13
        
           ../../tools/misc/binutils/build-components-separately.patch

     

       14
        
         ];

     

       15

+1 -1

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

···

       64
        
           # being generated to make sure that they use our glibc.

     

       65
        
           EXTRA_FLAGS="-I$NIX_FIXINC_DUMMY $(cat $NIX_CC/nix-support/libc-cflags) -O2"

     

       66
        
       

     

       67
       -
           extraLDFlags="-L$glibc_libdir -rpath $glibc_libdir $(cat $NIX_CC/nix-support/libc-ldflags) $(cat $NIX_CC/nix-support/libc-ldflags-before)"

     

       68
        
           for i in $extraLDFlags; do

     

       69
        
             EXTRA_FLAGS="$EXTRA_FLAGS -Wl,$i"

     

       70
        
           done

···

       64
        
           # being generated to make sure that they use our glibc.

     

       65
        
           EXTRA_FLAGS="-I$NIX_FIXINC_DUMMY $(cat $NIX_CC/nix-support/libc-cflags) -O2"

     

       66
        
       

     

       67
       +
           extraLDFlags="-L$glibc_libdir -rpath $glibc_libdir $(cat $NIX_BINTOOLS/nix-support/libc-ldflags) $(cat $NIX_BINTOOLS/nix-support/libc-ldflags-before)"

     

       68
        
           for i in $extraLDFlags; do

     

       69
        
             EXTRA_FLAGS="$EXTRA_FLAGS -Wl,$i"

     

       70
        
           done

+2 -2

pkgs/development/libraries/libuv/default.nix

···

       2
        
       , ApplicationServices, CoreServices }:

     

       3
        
       

     

       4
        
       stdenv.mkDerivation rec {

     

       5
       -
         version = "1.16.1";

     

       6
        
         name = "libuv-${version}";

     

       7
        
       

     

       8
        
         src = fetchFromGitHub {

     

       9
        
           owner = "libuv";

     

       10
        
           repo = "libuv";

     

       11
        
           rev = "v${version}";

     

       12
       -
           sha256 = "06p3xy276spqbr9xzbs7qlpdk34qsn87s2qmp6xn4j7v3bnqja7z";

     

       13
        
         };

     

       14
        
       

     

       15
        
         postPatch = let

···

       2
        
       , ApplicationServices, CoreServices }:

     

       3
        
       

     

       4
        
       stdenv.mkDerivation rec {

     

       5
       +
         version = "1.18.0";

     

       6
        
         name = "libuv-${version}";

     

       7
        
       

     

       8
        
         src = fetchFromGitHub {

     

       9
        
           owner = "libuv";

     

       10
        
           repo = "libuv";

     

       11
        
           rev = "v${version}";

     

       12
       +
           sha256 = "0s71c2y4ll3vp463hsdk74q4hr7wprkxc2a4agw3za2hhzcb95pd";

     

       13
        
         };

     

       14
        
       

     

       15
        
         postPatch = let

+29

pkgs/development/libraries/libva-utils/default.nix

···

       1
       +
       { stdenv, lib, fetchFromGitHub, autoreconfHook, pkgconfig

     

       2
       +
       , libdrm, libva

     

       3
       +
       }:

     

       4
       +
       

     

       5
       +
       stdenv.mkDerivation rec {

     

       6
       +
         name = "libva-utils-${version}";

     

       7
       +
         inherit (libva) version;

     

       8
       +
       

     

       9
       +
         src = fetchFromGitHub {

     

       10
       +
           owner  = "01org";

     

       11
       +
           repo   = "libva-utils";

     

       12
       +
           rev    = version;

     

       13
       +
           sha256 = "02n51cvp8bzzjk4fargwvgh7z71y8spg24hqgaawbp3p3ahh7xxi";

     

       14
       +
         };

     

       15
       +
       

     

       16
       +
         nativeBuildInputs = [ autoreconfHook pkgconfig ];

     

       17
       +
       

     

       18
       +
         buildInputs = [ libdrm libva ];

     

       19
       +
       

     

       20
       +
         enableParallelBuilding = true;

     

       21
       +
       

     

       22
       +
         meta = with stdenv.lib; {

     

       23
       +
           description = "VAAPI tools: Video Acceleration API";

     

       24
       +
           homepage = http://www.freedesktop.org/wiki/Software/vaapi;

     

       25
       +
           license = licenses.mit;

     

       26
       +
           maintainers = with maintainers; [ garbas ];

     

       27
       +
           platforms = platforms.unix;

     

       28
       +
         };

     

       29
       +
       }

+21 -14

pkgs/development/libraries/libva/default.nix

···

       1
       -
       { stdenv, lib, fetchurl, libX11, pkgconfig, libXext, libdrm, libXfixes, wayland, libffi

     

       0
        
       
     

       2
        
       , mesa_noglu

     

       3
        
       , minimal ? true, libva

     

       4
        
       }:

     

       5
        
       

     

       6
        
       stdenv.mkDerivation rec {

     

       7
       -
         name = "libva-${version}";

     

       8
       -
         version = "1.7.3";

     

       9
        
       

     

       10
       -
         src = fetchurl {

     

       11
       -
           url = "http://www.freedesktop.org/software/vaapi/releases/libva/${name}.tar.bz2";

     

       12
       -
           sha256 = "1ndrf136rlw03xag7j1xpmf9015d1h0dpnv6v587jnh6k2a17g12";

     

       0
        
       
     

       0
        
       
     

       13
        
         };

     

       14
        
       

     

       15
       -
         outputs = [ "bin" "dev" "out" ];

     

       16
        
       

     

       17
       -
         nativeBuildInputs = [ pkgconfig ];

     

       18
        
       

     

       19
        
         buildInputs = [ libdrm ]

     

       20
        
           ++ lib.optionals (!minimal) [ libva libX11 libXext libXfixes wayland libffi mesa_noglu ];

     

       21
        
         # TODO: share libs between minimal and !minimal - perhaps just symlink them

     

       22
        
       

     

       23
       -
         configureFlags =

     

       24
       -
           [ "--with-drivers-path=${mesa_noglu.driverLink}/lib/dri" ] ++

     

       25
       -
           lib.optionals (!minimal) [ "--enable-glx" ];

     

       0
        
       
     

       0
        
       
     

       26
        
       

     

       27
       -
         installFlags = [ "dummy_drv_video_ladir=$(out)/lib/dri" ];

     

       0
        
       
     

       0
        
       
     

       28
        
       

     

       29
        
         meta = with stdenv.lib; {

     

       0
        
       
     

       30
        
           homepage = http://www.freedesktop.org/wiki/Software/vaapi;

     

       31
        
           license = licenses.mit;

     

       32
       -
           description = "VAAPI library: Video Acceleration API";

     

       33
       -
           platforms = platforms.unix;

     

       34
        
           maintainers = with maintainers; [ garbas ];

     

       0
        
       
     

       35
        
         };

     

       36
        
       }

···

       1
       +
       { stdenv, lib, fetchFromGitHub, autoreconfHook, pkgconfig

     

       2
       +
       , libXext, libdrm, libXfixes, wayland, libffi, libX11

     

       3
        
       , mesa_noglu

     

       4
        
       , minimal ? true, libva

     

       5
        
       }:

     

       6
        
       

     

       7
        
       stdenv.mkDerivation rec {

     

       8
       +
         name = "libva-${lib.optionalString (!minimal) "full-"}${version}";

     

       9
       +
         version = "2.0.0";

     

       10
        
       

     

       11
       +
         src = fetchFromGitHub {

     

       12
       +
           owner  = "01org";

     

       13
       +
           repo   = "libva";

     

       14
       +
           rev    = version;

     

       15
       +
           sha256 = "1x8rlmv5wfqjz3j87byrxb4d9vp5b4lrrin2fx254nwl3aqy15hy";

     

       16
        
         };

     

       17
        
       

     

       18
       +
         outputs = [ "dev" "out" ];

     

       19
        
       

     

       20
       +
         nativeBuildInputs = [ autoreconfHook pkgconfig ];

     

       21
        
       

     

       22
        
         buildInputs = [ libdrm ]

     

       23
        
           ++ lib.optionals (!minimal) [ libva libX11 libXext libXfixes wayland libffi mesa_noglu ];

     

       24
        
         # TODO: share libs between minimal and !minimal - perhaps just symlink them

     

       25
        
       

     

       26
       +
         enableParallelBuilding = true;

     

       27
       +
       

     

       28
       +
         configureFlags = [

     

       29
       +
           "--with-drivers-path=${mesa_noglu.driverLink}/lib/dri"

     

       30
       +
         ] ++ lib.optionals (!minimal) [ "--enable-glx" ];

     

       31
        
       

     

       32
       +
         installFlags = [

     

       33
       +
           "dummy_drv_video_ladir=$(out)/lib/dri"

     

       34
       +
         ];

     

       35
        
       

     

       36
        
         meta = with stdenv.lib; {

     

       37
       +
           description = "VAAPI library: Video Acceleration API";

     

       38
        
           homepage = http://www.freedesktop.org/wiki/Software/vaapi;

     

       39
        
           license = licenses.mit;

     

       0
        
       
     

       0
        
       
     

       40
        
           maintainers = with maintainers; [ garbas ];

     

       41
       +
           platforms = platforms.unix;

     

       42
        
         };

     

       43
        
       }

+2 -2

pkgs/development/libraries/mesa/default.nix

···

       66
        
       in

     

       67
        
       

     

       68
        
       let

     

       69
       -
         version = "17.2.6";

     

       70
        
         branch  = head (splitString "." version);

     

       71
        
         driverLink = "/run/opengl-driver" + optionalString stdenv.isi686 "-32";

     

       72
        
       in

     
···

       81
        
             "ftp://ftp.freedesktop.org/pub/mesa/older-versions/${branch}.x/${version}/mesa-${version}.tar.xz"

     

       82
        
             "https://mesa.freedesktop.org/archive/mesa-${version}.tar.xz"

     

       83
        
           ];

     

       84
       -
           sha256 = "1pihiymglf3bf6w2vphac65v64hv71wgrj38mckbwc03c8j55n3a";

     

       85
        
         };

     

       86
        
       

     

       87
        
         prePatch = "patchShebangs .";

···

       66
        
       in

     

       67
        
       

     

       68
        
       let

     

       69
       +
         version = "17.2.7";

     

       70
        
         branch  = head (splitString "." version);

     

       71
        
         driverLink = "/run/opengl-driver" + optionalString stdenv.isi686 "-32";

     

       72
        
       in

     
···

       81
        
             "ftp://ftp.freedesktop.org/pub/mesa/older-versions/${branch}.x/${version}/mesa-${version}.tar.xz"

     

       82
        
             "https://mesa.freedesktop.org/archive/mesa-${version}.tar.xz"

     

       83
        
           ];

     

       84
       +
           sha256 = "0s3slgjxnx482yw0knn4a6alsy2cq28rah6hnjbmf12mvyldxksh";

     

       85
        
         };

     

       86
        
       

     

       87
        
         prePatch = "patchShebangs .";

+10 -6

pkgs/development/libraries/vaapi-intel/default.nix

···

       1
       -
       { stdenv, fetchurl, gnum4, pkgconfig, python2

     

       2
        
       , intel-gpu-tools, libdrm, libva, libX11, mesa_noglu, wayland, libXext

     

       3
        
       }:

     

       4
        
       

     

       5
        
       stdenv.mkDerivation rec {

     

       6
        
         name = "intel-vaapi-driver-${version}";

     

       7
       -
         version = "1.8.2";

     

       8
        
       

     

       9
       -
         src = fetchurl {

     

       10
       -
           url = "http://www.freedesktop.org/software/vaapi/releases/libva-intel-driver/${name}.tar.bz2";

     

       11
       -
           sha256 = "00mpcvininwr5c4wyhp16s4bddg7vclxxjm2sfq5h7lifjcxyv46";

     

       0
        
       
     

       0
        
       
     

       12
        
         };

     

       13
        
       

     

       14
        
         patchPhase = ''

     
···

       25
        
           "--enable-wayland"

     

       26
        
         ];

     

       27
        
       

     

       28
       -
         nativeBuildInputs = [ gnum4 pkgconfig python2 ];

     

       29
        
       

     

       30
        
         buildInputs = [ intel-gpu-tools libdrm libva libX11 libXext mesa_noglu wayland ];

     

       0
        
       
     

       0
        
       
     

       31
        
       

     

       32
        
         meta = with stdenv.lib; {

     

       33
        
           homepage = http://cgit.freedesktop.org/vaapi/intel-driver/;

···

       1
       +
       { stdenv, fetchFromGitHub, autoreconfHook, gnum4, pkgconfig, python2

     

       2
        
       , intel-gpu-tools, libdrm, libva, libX11, mesa_noglu, wayland, libXext

     

       3
        
       }:

     

       4
        
       

     

       5
        
       stdenv.mkDerivation rec {

     

       6
        
         name = "intel-vaapi-driver-${version}";

     

       7
       +
         inherit (libva) version;

     

       8
        
       

     

       9
       +
         src = fetchFromGitHub {

     

       10
       +
           owner  = "01org";

     

       11
       +
           repo   = "libva-intel-driver";

     

       12
       +
           rev    = version;

     

       13
       +
           sha256 = "1832nnva3d33wv52bj59bv62q7a807sdxjqqq0my7l9x7a4qdkzz";

     

       14
        
         };

     

       15
        
       

     

       16
        
         patchPhase = ''

     
···

       27
        
           "--enable-wayland"

     

       28
        
         ];

     

       29
        
       

     

       30
       +
         nativeBuildInputs = [ autoreconfHook gnum4 pkgconfig python2 ];

     

       31
        
       

     

       32
        
         buildInputs = [ intel-gpu-tools libdrm libva libX11 libXext mesa_noglu wayland ];

     

       33
       +
       

     

       34
       +
         enableParallelBuilding = true;

     

       35
        
       

     

       36
        
         meta = with stdenv.lib; {

     

       37
        
           homepage = http://cgit.freedesktop.org/vaapi/intel-driver/;

+1 -4

pkgs/development/perl-modules/generic/builder.sh

···

       17
        
                   first=$(dd if="$fn" count=2 bs=1 2> /dev/null)

     

       18
        
                   if test "$first" = "#!"; then

     

       19
        
                       echo "patching $fn..."

     

       20
       -
                       sed < "$fn" > "$fn".tmp \

     

       21
       -
                           -e "s|^#\!\(.*/perl.*\)$|#\! \1$perlFlags|"

     

       22
       -
                       if test -x "$fn"; then chmod +x "$fn".tmp; fi

     

       23
       -
                       mv "$fn".tmp "$fn"

     

       24
        
                   fi

     

       25
        
               fi

     

       26
        
           done

···

       17
        
                   first=$(dd if="$fn" count=2 bs=1 2> /dev/null)

     

       18
        
                   if test "$first" = "#!"; then

     

       19
        
                       echo "patching $fn..."

     

       20
       +
                       sed -i "$fn" -e "s|^#\!\(.*[ /]perl.*\)$|#\!\1$perlFlags|"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       21
        
                   fi

     

       22
        
               fi

     

       23
        
           done

+1 -1

pkgs/development/tools/bloaty/default.nix

···

       19
        
         preConfigure = ''

     

       20
        
           substituteInPlace src/bloaty.cc \

     

       21
        
             --replace "c++filt" \

     

       22
       -
                       "${stdenv.lib.getBin binutils}/bin/c++filt"

     

       23
        
         '';

     

       24
        
       

     

       25
        
         doCheck = true;

···

       19
        
         preConfigure = ''

     

       20
        
           substituteInPlace src/bloaty.cc \

     

       21
        
             --replace "c++filt" \

     

       22
       +
                       "${binutils.bintools}/bin/c++filt"

     

       23
        
         '';

     

       24
        
       

     

       25
        
         doCheck = true;

+2 -2

pkgs/development/tools/build-managers/meson/default.nix

···

       1
        
       { lib, python3Packages }:

     

       2
        
       python3Packages.buildPythonApplication rec {

     

       3
       -
         version = "0.43.0";

     

       4
        
         pname = "meson";

     

       5
        
         name = "${pname}-${version}";

     

       6
        
       

     

       7
        
         src = python3Packages.fetchPypi {

     

       8
        
           inherit pname version;

     

       9
       -
           sha256 = "0qn5hyzvam3rimn7g3671s1igj7fbkwdnf5nc8jr4d5swy25mq61";

     

       10
        
         };

     

       11
        
       

     

       12
        
         postFixup = ''

···

       1
        
       { lib, python3Packages }:

     

       2
        
       python3Packages.buildPythonApplication rec {

     

       3
       +
         version = "0.44.0";

     

       4
        
         pname = "meson";

     

       5
        
         name = "${pname}-${version}";

     

       6
        
       

     

       7
        
         src = python3Packages.fetchPypi {

     

       8
        
           inherit pname version;

     

       9
       +
           sha256 = "1rpqp9iwbvr4xvfdh3iyfh1ha274hbb66jbgw3pa5a73x4d4ilqn";

     

       10
        
         };

     

       11
        
       

     

       12
        
         postFixup = ''

+1 -1

pkgs/development/tools/misc/binutils/default.nix

···

       55
        
           ./disambiguate-arm-targets.patch

     

       56
        
         ];

     

       57
        
       

     

       58
       -
         outputs = [ "out" "info" ];

     

       59
        
       

     

       60
        
         nativeBuildInputs = [ bison buildPackages.stdenv.cc ];

     

       61
        
         buildInputs = [ zlib ];

···

       55
        
           ./disambiguate-arm-targets.patch

     

       56
        
         ];

     

       57
        
       

     

       58
       +
         outputs = [ "out" "info" "man" ];

     

       59
        
       

     

       60
        
         nativeBuildInputs = [ bison buildPackages.stdenv.cc ];

     

       61
        
         buildInputs = [ zlib ];

+2 -2

pkgs/development/web/nodejs/v9.nix

···

       5
        
       in

     

       6
        
         buildNodejs {

     

       7
        
           inherit enableNpm;

     

       8
       -
           version = "9.2.0";

     

       9
       -
           sha256 = "1hmvwfbavk2axqz9kin8b5zsld25gznhvlz55h3yl6nwx9iz5jk4";

     

       10
        
           patches = lib.optionals stdenv.isDarwin [ ./no-xcode-v7.patch ];

     

       11
        
         }

···

       5
        
       in

     

       6
        
         buildNodejs {

     

       7
        
           inherit enableNpm;

     

       8
       +
           version = "9.3.0";

     

       9
       +
           sha256 = "1kap1hi4am5advfp6yb3bd5nhd2wx2j72cjq8qqg7yh95xg0g25j";

     

       10
        
           patches = lib.optionals stdenv.isDarwin [ ./no-xcode-v7.patch ];

     

       11
        
         }

+10 -3

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

···

       17
        
       # TODO loop over targetPrefixed binaries too

     

       18
        
       stdenv.mkDerivation {

     

       19
        
         name = "${targetPrefix}cctools-binutils-darwin";

     

       0
        
       
     

       20
        
         buildCommand = ''

     

       21
        
           mkdir -p $out/bin $out/include

     

       22
        
       

     

       23
       -
           ln -s ${binutils-raw.out}/bin/${targetPrefix}c++filt $out/bin/${targetPrefix}c++filt

     

       24
        
       

     

       25
        
           # We specifically need:

     

       26
        
           # - ld: binutils doesn't provide it on darwin

     
···

       37
        
             ln -sf "${cctools}/bin/$i" "$out/bin/$i"

     

       38
        
           done

     

       39
        
       

     

       40
       -
           # FIXME: this will give us incorrect man pages for bits of cctools

     

       41
       -
           ln -s ${binutils-raw.out}/share $out/share

     

       42
        
       

     

       43
        
           ln -s ${cctools}/libexec $out/libexec

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       44
        
         '';

     

       45
        
       

     

       46
        
         passthru = {

···

       17
        
       # TODO loop over targetPrefixed binaries too

     

       18
        
       stdenv.mkDerivation {

     

       19
        
         name = "${targetPrefix}cctools-binutils-darwin";

     

       20
       +
         outputs = [ "out" "info" "man" ];

     

       21
        
         buildCommand = ''

     

       22
        
           mkdir -p $out/bin $out/include

     

       23
        
       

     

       24
       +
           ln -s ${binutils-raw.bintools.out}/bin/${targetPrefix}c++filt $out/bin/${targetPrefix}c++filt

     

       25
        
       

     

       26
        
           # We specifically need:

     

       27
        
           # - ld: binutils doesn't provide it on darwin

     
···

       38
        
             ln -sf "${cctools}/bin/$i" "$out/bin/$i"

     

       39
        
           done

     

       40
        
       

     

       41
       +
           ln -s ${binutils-raw.bintools.out}/share $out/share

     

       0
        
       
     

       42
        
       

     

       43
        
           ln -s ${cctools}/libexec $out/libexec

     

       44
       +
       

     

       45
       +
           mkdir -p "$info/nix-support" "$man/nix-support"

     

       46
       +
           printWords ${binutils-raw.bintools.info} \

     

       47
       +
             >> $info/nix-support/propagated-build-inputs

     

       48
       +
           # FIXME: cctools missing man pages

     

       49
       +
           printWords ${binutils-raw.bintools.man} \

     

       50
       +
             >> $man/nix-support/propagated-build-inputs

     

       51
        
         '';

     

       52
        
       

     

       53
        
         passthru = {

+39 -23

pkgs/stdenv/darwin/default.nix

···

       60
        
                                 extraBuildInputs,

     

       61
        
                                 allowedRequisites ? null}:

     

       62
        
           let

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
             thisStdenv = import ../generic {

     

       64
        
               inherit config shell extraNativeBuildInputs extraBuildInputs;

     

       65
        
               allowedRequisites = if allowedRequisites == null then null else allowedRequisites ++ [

     

       66
       -
                 thisStdenv.cc.expand-response-params

     

       67
        
               ];

     

       68
        
       

     

       69
        
               name = "stdenv-darwin-boot-${toString step}";

     
···

       72
        
               hostPlatform = localSystem;

     

       73
        
               targetPlatform = localSystem;

     

       74
        
       

     

       75
       -
               cc = if isNull last then "/dev/null" else import ../../build-support/cc-wrapper {

     

       76
       -
                 inherit shell;

     

       77
       -
                 inherit (last) stdenvNoCC;

     

       78
        
       

     

       79
       -
                 nativeTools  = false;

     

       80
       -
                 nativeLibc   = false;

     

       81
       -
                 buildPackages = lib.optionalAttrs (last ? stdenv) {

     

       82
       -
                   inherit (last) stdenv;

     

       83
       -
                 };

     

       84
       -
                 libc         = last.pkgs.darwin.Libsystem;

     

       85
       -
                 isClang      = true;

     

       86
       -
                 cc           = { name = "clang-9.9.9";     outPath = bootstrapTools; };

     

       87
       -
                 binutils     = { name = "binutils-9.9.9";  outPath = bootstrapTools; };

     

       88
       -
                 coreutils    = { name = "coreutils-9.9.9"; outPath = bootstrapTools; };

     

       89
       -
                 gnugrep      = { name = "gnugrep-9.9.9";   outPath = bootstrapTools; };

     

       90
       -
               };

     

       91
       -
       

     

       92
       -
               preHook = stage0.stdenv.lib.optionalString (shell == "${bootstrapTools}/bin/bash") ''

     

       93
        
                 # Don't patch #!/interpreter because it leads to retained

     

       94
        
                 # dependencies on the bootstrapTools in the final stdenv.

     

       95
        
                 dontPatchShebangs=1

     
···

       328
        
             buildPackages = {

     

       329
        
               inherit (prevStage) stdenv;

     

       330
        
             };

     

       331
       -
             inherit (pkgs) coreutils binutils gnugrep;

     

       332
       -
             cc   = pkgs.llvmPackages.clang-unwrapped;

     

       333
       -
             libc = pkgs.darwin.Libsystem;

     

       0
        
       
     

       334
        
           };

     

       335
        
       

     

       336
        
           extraNativeBuildInputs = [];

     
···

       349
        
             xz.out xz.bin libcxx libcxxabi gmp.out gnumake findutils bzip2.out

     

       350
        
             bzip2.bin llvmPackages.llvm llvmPackages.llvm.lib zlib.out zlib.dev libffi.out coreutils ed diffutils gnutar

     

       351
        
             gzip ncurses.out ncurses.dev ncurses.man gnused bash gawk

     

       352
       -
             gnugrep llvmPackages.clang-unwrapped patch pcre.out binutils-raw.out

     

       353
       -
             binutils gettext

     

       354
        
             cc.expand-response-params

     

       355
        
           ]) ++ (with pkgs.darwin; [

     

       356
        
             dyld Libsystem CF cctools ICU libiconv locale

···

       60
        
                                 extraBuildInputs,

     

       61
        
                                 allowedRequisites ? null}:

     

       62
        
           let

     

       63
       +
             buildPackages = lib.optionalAttrs (last ? stdenv) {

     

       64
       +
               inherit (last) stdenv;

     

       65
       +
             };

     

       66
       +
       

     

       67
       +
             coreutils = { name = "coreutils-9.9.9"; outPath = bootstrapTools; };

     

       68
       +
             gnugrep   = { name = "gnugrep-9.9.9";   outPath = bootstrapTools; };

     

       69
       +
       

     

       70
       +
             bintools = import ../../build-support/bintools-wrapper {

     

       71
       +
               inherit shell;

     

       72
       +
               inherit (last) stdenvNoCC;

     

       73
       +
       

     

       74
       +
               nativeTools  = false;

     

       75
       +
               nativeLibc   = false;

     

       76
       +
               inherit buildPackages coreutils gnugrep;

     

       77
       +
               libc         = last.pkgs.darwin.Libsystem;

     

       78
       +
               bintools     = { name = "binutils-9.9.9";  outPath = bootstrapTools; };

     

       79
       +
             };

     

       80
       +
       

     

       81
       +
             cc = if isNull last then "/dev/null" else import ../../build-support/cc-wrapper {

     

       82
       +
               inherit shell;

     

       83
       +
               inherit (last) stdenvNoCC;

     

       84
       +
       

     

       85
       +
               nativeTools  = false;

     

       86
       +
               nativeLibc   = false;

     

       87
       +
               inherit buildPackages coreutils gnugrep bintools;

     

       88
       +
               libc         = last.pkgs.darwin.Libsystem;

     

       89
       +
               isClang      = true;

     

       90
       +
               cc           = { name = "clang-9.9.9";     outPath = bootstrapTools; };

     

       91
       +
             };

     

       92
       +
       

     

       93
        
             thisStdenv = import ../generic {

     

       94
        
               inherit config shell extraNativeBuildInputs extraBuildInputs;

     

       95
        
               allowedRequisites = if allowedRequisites == null then null else allowedRequisites ++ [

     

       96
       +
                 cc.expand-response-params cc.bintools

     

       97
        
               ];

     

       98
        
       

     

       99
        
               name = "stdenv-darwin-boot-${toString step}";

     
···

       102
        
               hostPlatform = localSystem;

     

       103
        
               targetPlatform = localSystem;

     

       104
        
       

     

       105
       +
               inherit cc;

     

       0
        
       
     

       0
        
       
     

       106
        
       

     

       107
       +
               preHook = lib.optionalString (shell == "${bootstrapTools}/bin/bash") ''

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       108
        
                 # Don't patch #!/interpreter because it leads to retained

     

       109
        
                 # dependencies on the bootstrapTools in the final stdenv.

     

       110
        
                 dontPatchShebangs=1

     
···

       343
        
             buildPackages = {

     

       344
        
               inherit (prevStage) stdenv;

     

       345
        
             };

     

       346
       +
             inherit (pkgs) coreutils gnugrep;

     

       347
       +
             cc       = pkgs.llvmPackages.clang-unwrapped;

     

       348
       +
             bintools = pkgs.darwin.binutils;

     

       349
       +
             libc     = pkgs.darwin.Libsystem;

     

       350
        
           };

     

       351
        
       

     

       352
        
           extraNativeBuildInputs = [];

     
···

       365
        
             xz.out xz.bin libcxx libcxxabi gmp.out gnumake findutils bzip2.out

     

       366
        
             bzip2.bin llvmPackages.llvm llvmPackages.llvm.lib zlib.out zlib.dev libffi.out coreutils ed diffutils gnutar

     

       367
        
             gzip ncurses.out ncurses.dev ncurses.man gnused bash gawk

     

       368
       +
             gnugrep llvmPackages.clang-unwrapped patch pcre.out gettext

     

       369
       +
             binutils-raw.bintools binutils binutils.bintools

     

       370
        
             cc.expand-response-params

     

       371
        
           ]) ++ (with pkgs.darwin; [

     

       372
        
             dyld Libsystem CF cctools ICU libiconv locale

+33 -9

pkgs/stdenv/linux/default.nix

···

       80
        
                   inherit (prevStage) stdenv;

     

       81
        
                 };

     

       82
        
                 cc = prevStage.gcc-unwrapped;

     

       0
        
       
     

       83
        
                 isGNU = true;

     

       84
        
                 libc = prevStage.glibc;

     

       85
       -
                 inherit (prevStage) binutils coreutils gnugrep;

     

       86
        
                 name = name;

     

       87
        
                 stdenvNoCC = prevStage.ccWrapperStdenv;

     

       88
        
               };

     
···

       143
        
               '';

     

       144
        
             };

     

       145
        
             gcc-unwrapped = bootstrapTools;

     

       146
       -
             binutils = bootstrapTools;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       147
        
             coreutils = bootstrapTools;

     

       148
        
             gnugrep = bootstrapTools;

     

       149
        
           };

     
···

       165
        
       

     

       166
        
           # Rebuild binutils to use from stage2 onwards.

     

       167
        
           overrides = self: super: {

     

       168
       -
             binutils = super.binutils.override { gold = false; };

     

       169
        
             inherit (prevStage)

     

       170
        
               ccWrapperStdenv

     

       171
        
               glibc gcc-unwrapped coreutils gnugrep;

     
···

       188
        
           overrides = self: super: {

     

       189
        
             inherit (prevStage)

     

       190
        
               ccWrapperStdenv

     

       191
       -
               binutils gcc-unwrapped coreutils gnugrep

     

       192
        
               perl paxctl gnum4 bison;

     

       193
        
             # This also contains the full, dynamically linked, final Glibc.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       194
        
           };

     

       195
        
         })

     

       196
        
       

     
···

       235
        
             # other purposes (binutils and top-level pkgs) too.

     

       236
        
             inherit (prevStage) gettext gnum4 bison gmp perl glibc zlib linuxHeaders;

     

       237
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       238
        
             gcc = lib.makeOverridable (import ../../build-support/cc-wrapper) {

     

       239
        
               nativeTools = false;

     

       240
        
               nativeLibc = false;

     
···

       243
        
                 inherit (prevStage) stdenv;

     

       244
        
               };

     

       245
        
               cc = prevStage.gcc-unwrapped;

     

       0
        
       
     

       246
        
               libc = self.glibc;

     

       247
       -
               inherit (self) stdenvNoCC binutils coreutils gnugrep;

     

       248
        
               name = "";

     

       249
        
               shell = self.bash + "/bin/bash";

     

       250
        
             };

     
···

       299
        
             allowedRequisites = with prevStage; with lib;

     

       300
        
               # Simple executable tools

     

       301
        
               concatMap (p: [ (getBin p) (getLib p) ])

     

       302
       -
                 [ gzip bzip2 xz bash binutils coreutils diffutils findutils gawk

     

       303
       -
                   gnumake gnused gnutar gnugrep gnupatch patchelf ed paxctl

     

       304
        
                 ]

     

       305
        
               # Library dependencies

     

       306
        
               ++ map getLib (

     
···

       310
        
               # More complicated cases

     

       311
        
               ++ [

     

       312
        
                   glibc.out glibc.dev glibc.bin/*propagated from .dev*/ linuxHeaders

     

       313
       -
                   gcc gcc.cc gcc.cc.lib gcc.expand-response-params

     

       314
        
                 ]

     

       315
        
                 ++ lib.optionals localSystem.isAarch64

     

       316
        
                   [ prevStage.updateAutotoolsGnuConfigScriptsHook prevStage.gnu-config ];

     
···

       322
        
                 attr acl paxctl zlib pcre;

     

       323
        
             } // lib.optionalAttrs (super.targetPlatform == localSystem) {

     

       324
        
               # Need to get rid of these when cross-compiling.

     

       325
       -
               inherit (prevStage) binutils;

     

       326
        
               gcc = cc;

     

       327
        
             };

     

       328
        
           };

···

       80
        
                   inherit (prevStage) stdenv;

     

       81
        
                 };

     

       82
        
                 cc = prevStage.gcc-unwrapped;

     

       83
       +
                 bintools = prevStage.binutils;

     

       84
        
                 isGNU = true;

     

       85
        
                 libc = prevStage.glibc;

     

       86
       +
                 inherit (prevStage) coreutils gnugrep;

     

       87
        
                 name = name;

     

       88
        
                 stdenvNoCC = prevStage.ccWrapperStdenv;

     

       89
        
               };

     
···

       144
        
               '';

     

       145
        
             };

     

       146
        
             gcc-unwrapped = bootstrapTools;

     

       147
       +
             binutils = import ../../build-support/bintools-wrapper {

     

       148
       +
               nativeTools = false;

     

       149
       +
               nativeLibc = false;

     

       150
       +
               buildPackages = { };

     

       151
       +
               libc = self.glibc;

     

       152
       +
               inherit (self) stdenvNoCC coreutils gnugrep;

     

       153
       +
               bintools = bootstrapTools;

     

       154
       +
               name = "bootstrap-binutils-wrapper";

     

       155
       +
             };

     

       156
        
             coreutils = bootstrapTools;

     

       157
        
             gnugrep = bootstrapTools;

     

       158
        
           };

     
···

       174
        
       

     

       175
        
           # Rebuild binutils to use from stage2 onwards.

     

       176
        
           overrides = self: super: {

     

       177
       +
             binutils = super.binutils_nogold;

     

       178
        
             inherit (prevStage)

     

       179
        
               ccWrapperStdenv

     

       180
        
               glibc gcc-unwrapped coreutils gnugrep;

     
···

       197
        
           overrides = self: super: {

     

       198
        
             inherit (prevStage)

     

       199
        
               ccWrapperStdenv

     

       200
       +
               gcc-unwrapped coreutils gnugrep

     

       201
        
               perl paxctl gnum4 bison;

     

       202
        
             # This also contains the full, dynamically linked, final Glibc.

     

       203
       +
             binutils = prevStage.binutils.override {

     

       204
       +
               # Rewrap the binutils with the new glibc, so both the next

     

       205
       +
               # stage's wrappers use it.

     

       206
       +
               libc = self.glibc;

     

       207
       +
             };

     

       208
        
           };

     

       209
        
         })

     

       210
        
       

     
···

       249
        
             # other purposes (binutils and top-level pkgs) too.

     

       250
        
             inherit (prevStage) gettext gnum4 bison gmp perl glibc zlib linuxHeaders;

     

       251
        
       

     

       252
       +
             binutils = super.binutils.override {

     

       253
       +
               # Don't use stdenv's shell but our own

     

       254
       +
               shell = self.bash + "/bin/bash";

     

       255
       +
               # Build expand-response-params with last stage like below

     

       256
       +
               buildPackages = {

     

       257
       +
                 inherit (prevStage) stdenv;

     

       258
       +
               };

     

       259
       +
             };

     

       260
       +
       

     

       261
        
             gcc = lib.makeOverridable (import ../../build-support/cc-wrapper) {

     

       262
        
               nativeTools = false;

     

       263
        
               nativeLibc = false;

     
···

       266
        
                 inherit (prevStage) stdenv;

     

       267
        
               };

     

       268
        
               cc = prevStage.gcc-unwrapped;

     

       269
       +
               bintools = self.binutils;

     

       270
        
               libc = self.glibc;

     

       271
       +
               inherit (self) stdenvNoCC coreutils gnugrep;

     

       272
        
               name = "";

     

       273
        
               shell = self.bash + "/bin/bash";

     

       274
        
             };

     
···

       323
        
             allowedRequisites = with prevStage; with lib;

     

       324
        
               # Simple executable tools

     

       325
        
               concatMap (p: [ (getBin p) (getLib p) ])

     

       326
       +
                 [ gzip bzip2 xz bash binutils.bintools coreutils diffutils findutils

     

       327
       +
                   gawk gnumake gnused gnutar gnugrep gnupatch patchelf ed paxctl

     

       328
        
                 ]

     

       329
        
               # Library dependencies

     

       330
        
               ++ map getLib (

     
···

       334
        
               # More complicated cases

     

       335
        
               ++ [

     

       336
        
                   glibc.out glibc.dev glibc.bin/*propagated from .dev*/ linuxHeaders

     

       337
       +
                   binutils gcc gcc.cc gcc.cc.lib gcc.expand-response-params

     

       338
        
                 ]

     

       339
        
                 ++ lib.optionals localSystem.isAarch64

     

       340
        
                   [ prevStage.updateAutotoolsGnuConfigScriptsHook prevStage.gnu-config ];

     
···

       346
        
                 attr acl paxctl zlib pcre;

     

       347
        
             } // lib.optionalAttrs (super.targetPlatform == localSystem) {

     

       348
        
               # Need to get rid of these when cross-compiling.

     

       349
       +
               inherit (prevStage) binutils binutils-raw;

     

       350
        
               gcc = cc;

     

       351
        
             };

     

       352
        
           };

+1 -1

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

···

       177
        
       

     

       178
        
               # Copy binutils.

     

       179
        
               for i in as ld ar ranlib nm strip readelf objdump; do

     

       180
       -
                 cp ${binutils.out}/bin/$i $out/bin

     

       181
        
               done

     

       182
        
       

     

       183
        
               chmod -R u+w $out

···

       177
        
       

     

       178
        
               # Copy binutils.

     

       179
        
               for i in as ld ar ranlib nm strip readelf objdump; do

     

       180
       +
                 cp ${binutils.bintools.out}/bin/$i $out/bin

     

       181
        
               done

     

       182
        
       

     

       183
        
               chmod -R u+w $out

+1 -1

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

···

       126
        
       

     

       127
        
               # Copy binutils.

     

       128
        
               for i in as ld ar ranlib nm strip readelf objdump; do

     

       129
       -
                 cp ${binutils.out}/bin/$i $out/bin

     

       130
        
               done

     

       131
        
       

     

       132
        
               chmod -R u+w $out

···

       126
        
       

     

       127
        
               # Copy binutils.

     

       128
        
               for i in as ld ar ranlib nm strip readelf objdump; do

     

       129
       +
                 cp ${binutils.bintools.out}/bin/$i $out/bin

     

       130
        
               done

     

       131
        
       

     

       132
        
               chmod -R u+w $out

+37

pkgs/test/cc-wrapper/multilib.nix

···

       1
       +
       { stdenv }:

     

       2
       +
       

     

       3
       +
       stdenv.mkDerivation {

     

       4
       +
         name = "cc-multilib-test";

     

       5
       +
       

     

       6
       +
         # XXX: "depend" on cc-wrapper test?

     

       7
       +
       

     

       8
       +
         # TODO: Have tests report pointer size or something; ensure they are what we asked for

     

       9
       +
         buildCommand = ''

     

       10
       +
           NIX_DEBUG=1 $CC -v

     

       11
       +
           NIX_DEBUG=1 $CXX -v

     

       12
       +
       

     

       13
       +
           printf "checking whether compiler builds valid C binaries... " >&2

     

       14
       +
           $CC -o cc-check ${./cc-main.c}

     

       15
       +
           ./cc-check

     

       16
       +
       

     

       17
       +
           printf "checking whether compiler builds valid 32bit C binaries... " >&2

     

       18
       +
           $CC -m32 -o c32-check ${./cc-main.c}

     

       19
       +
           ./c32-check

     

       20
       +
       

     

       21
       +
           printf "checking whether compiler builds valid 64bit C binaries... " >&2

     

       22
       +
           $CC -m64 -o c64-check ${./cc-main.c}

     

       23
       +
           ./c64-check

     

       24
       +
       

     

       25
       +
           printf "checking whether compiler builds valid 32bit C++ binaries... " >&2

     

       26
       +
           $CXX -m32 -o cxx32-check ${./cxx-main.cc}

     

       27
       +
           ./cxx32-check

     

       28
       +
       

     

       29
       +
           printf "checking whether compiler builds valid 64bit C++ binaries... " >&2

     

       30
       +
           $CXX -m64 -o cxx64-check ${./cxx-main.cc}

     

       31
       +
           ./cxx64-check

     

       32
       +
       

     

       33
       +
           touch $out

     

       34
       +
         '';

     

       35
       +
       

     

       36
       +
         meta.platforms = stdenv.lib.platforms.x86_64;

     

       37
       +
       }

-4

pkgs/tools/typesetting/biber/default.nix

···

       32
        
         # Tests depend on the precise Unicode-Collate version (expects 1.19, but we have 1.25)

     

       33
        
         doCheck = false;

     

       34
        
       

     

       35
       -
         postUnpack = ''

     

       36
       -
           sed '1s/env perl/perl/' -i */bin/biber

     

       37
       -
         '';

     

       38
       -
       

     

       39
        
         meta = {

     

       40
        
           description = "Backend for BibLaTeX";

     

       41
        
           license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];

···

       32
        
         # Tests depend on the precise Unicode-Collate version (expects 1.19, but we have 1.25)

     

       33
        
         doCheck = false;

     

       34
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35
        
         meta = {

     

       36
        
           description = "Backend for BibLaTeX";

     

       37
        
           license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];

+67 -9

pkgs/top-level/all-packages.nix

···

       287
        
           inherit url;

     

       288
        
         };

     

       289
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       290
        
         libredirect = callPackage ../build-support/libredirect { };

     

       291
        
       

     

       292
        
         madonctl = callPackage ../applications/misc/madonctl { };

     
···

       5505
        
       

     

       5506
        
         clang-sierraHack = clang.override {

     

       5507
        
           name = "clang-wrapper-with-reexport-hack";

     

       5508
       -
           useMacosReexportHack = true;

     

       0
        
       
     

       0
        
       
     

       5509
        
         };

     

       5510
        
       

     

       5511
        
         clang_5  = llvmPackages_5.clang;

     
···

       5534
        
           cc = build;

     

       5535
        
           isClang = true;

     

       5536
        
           inherit stdenvNoCC;

     

       5537
       -
           libc = glibc;

     

       5538
        
           extraPackages = [ libcxx libcxxabi ];

     

       5539
        
           nativeTools = false;

     

       5540
        
           nativeLibc = false;

     
···

       5606
        
         };

     

       5607
        
       

     

       5608
        
         wrapCCMulti = cc:

     

       5609
       -
           if system == "x86_64-linux" then lowPrio (wrapCCWith {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5610
        
             cc = cc.cc.override {

     

       5611
        
               stdenv = overrideCC stdenv (wrapCCWith {

     

       5612
        
                 cc = cc.cc;

     

       0
        
       
     

       5613
        
                 libc = glibc_multi;

     

       5614
        
               });

     

       5615
        
               profiledCompiler = false;

     

       5616
        
               enableMultilib = true;

     

       5617
        
             };

     

       5618
       -
       

     

       5619
        
             libc = glibc_multi;

     

       5620
       -
       

     

       5621
        
             extraBuildCommands = ''

     

       5622
        
               echo "dontMoveLib64=1" >> $out/nix-support/setup-hook

     

       5623
        
             '';

     

       5624
        
         }) else throw "Multilib ${cc.name} not supported on ‘${system}’";

     

       5625
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5626
        
         gcc_multi = wrapCCMulti gcc;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5627
        
       

     

       5628
        
         gcc_debug = lowPrio (wrapCC (gcc.cc.override {

     

       5629
        
           stripped = false;

     
···

       5650
        
             if targetPlatform.libc == "msvcrt" then targetPackages.windows.mingw_w64_headers

     

       5651
        
             else if targetPlatform.libc == "libSystem" then darwin.xcode

     

       5652
        
             else null;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5653
        
           in wrapCCWith {

     

       5654
        
             name = "gcc-cross-wrapper";

     

       5655
        
             cc = gccFun {

     
···

       5663
        
               crossStageStatic = true;

     

       5664
        
               langCC = false;

     

       5665
        
               libcCross = libcCross1;

     

       0
        
       
     

       5666
        
               enableShared = false;

     

       5667
        
             };

     

       0
        
       
     

       5668
        
             libc = libcCross1;

     

       5669
        
         };

     

       5670
        
       

     
···

       5673
        
           name = "gcc-cross-wrapper";

     

       5674
        
           cc = gccCrossStageStatic.gcc;

     

       5675
        
           libc = windows.mingw_headers2;

     

       0
        
       
     

       5676
        
         };

     

       5677
        
       

     

       5678
        
         gcc45 = lowPrio (wrapCC (callPackage ../development/compilers/gcc/4.5 {

     
···

       6435
        
       

     

       6436
        
         wla-dx = callPackage ../development/compilers/wla-dx { };

     

       6437
        
       

     

       6438
       -
         wrapCCWith = { name ? "", cc, libc, extraBuildCommands ? "" }: ccWrapperFun rec {

     

       0
        
       
     

       6439
        
           nativeTools = targetPlatform == hostPlatform && stdenv.cc.nativeTools or false;

     

       6440
        
           nativeLibc = targetPlatform == hostPlatform && stdenv.cc.nativeLibc or false;

     

       6441
        
           nativePrefix = stdenv.cc.nativePrefix or "";

     
···

       6444
        
           isGNU = cc.isGNU or false;

     

       6445
        
           isClang = cc.isClang or false;

     

       6446
        
       

     

       6447
       -
           inherit name cc libc extraBuildCommands;

     

       6448
        
         };

     

       6449
        
       

     

       6450
        
         ccWrapperFun = callPackage ../build-support/cc-wrapper;

     

       0
        
       
     

       6451
        
       

     

       6452
        
         wrapCC = cc: wrapCCWith {

     

       6453
        
           name = lib.optionalString (targetPlatform != hostPlatform) "gcc-cross-wrapper";

     

       6454
        
           inherit cc;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6455
        
           libc = if targetPlatform != hostPlatform then libcCross else stdenv.cc.libc;

     

       6456
        
         };

     

       6457
        
         # legacy version, used for gnat bootstrapping

     
···

       6461
        
           nativePrefix = stdenv.cc.nativePrefix or "";

     

       6462
        
           gcc = baseGCC;

     

       6463
        
           libc = glibc;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6464
        
         };

     

       6465
        
       

     

       6466
        
         # prolog

     
···

       7044
        
           then darwin.binutils

     

       7045
        
           else binutils-raw;

     

       7046
        
       

     

       7047
       -
         binutils-raw = callPackage ../development/tools/misc/binutils {

     

       7048
        
           # FHS sys dirs presumably only have stuff for the build platform

     

       7049
        
           noSysDirs = (targetPlatform != buildPlatform) || noSysDirs;

     

       7050
        
         };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7051
        
       

     

       7052
        
         binutils_nogold = lowPrio (binutils-raw.override {

     

       7053
       -
           gold = false;

     

       0
        
       
     

       0
        
       
     

       7054
        
         });

     

       7055
        
       

     

       7056
        
         bison2 = callPackage ../development/tools/parsing/bison/2.x.nix { };

     
···

       9787
        
       

     

       9788
        
         libva = callPackage ../development/libraries/libva { };

     

       9789
        
         libva-full = libva.override { minimal = false; };

     

       0
        
       
     

       9790
        
       

     

       9791
        
         libvdpau = callPackage ../development/libraries/libvdpau { };

     

       9792
        
       

     
···

       20033
        
           cc-wrapper-clang-5 = callPackage ../test/cc-wrapper { stdenv = llvmPackages_5.stdenv; };

     

       20034
        
           cc-wrapper-libcxx-5 = callPackage ../test/cc-wrapper { stdenv = llvmPackages_5.libcxxStdenv; };

     

       20035
        
           stdenv-inputs = callPackage ../test/stdenv-inputs { };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20036
        
       

     

       20037
        
           macOSSierraShared = callPackage ../test/macos-sierra-shared {};

     

       20038
        
         };

···

       287
        
           inherit url;

     

       288
        
         };

     

       289
        
       

     

       290
       +
         ld-is-cc-hook = makeSetupHook { name = "ld-is-cc-hook"; }

     

       291
       +
           ../build-support/setup-hooks/ld-is-cc-hook.sh;

     

       292
       +
       

     

       293
        
         libredirect = callPackage ../build-support/libredirect { };

     

       294
        
       

     

       295
        
         madonctl = callPackage ../applications/misc/madonctl { };

     
···

       5508
        
       

     

       5509
        
         clang-sierraHack = clang.override {

     

       5510
        
           name = "clang-wrapper-with-reexport-hack";

     

       5511
       +
           bintools = clang.bintools.override {

     

       5512
       +
             useMacosReexportHack = true;

     

       5513
       +
           };

     

       5514
        
         };

     

       5515
        
       

     

       5516
        
         clang_5  = llvmPackages_5.clang;

     
···

       5539
        
           cc = build;

     

       5540
        
           isClang = true;

     

       5541
        
           inherit stdenvNoCC;

     

       5542
       +
           inherit (targetPackages.stdenv.cc) bintools libc;

     

       5543
        
           extraPackages = [ libcxx libcxxabi ];

     

       5544
        
           nativeTools = false;

     

       5545
        
           nativeLibc = false;

     
···

       5611
        
         };

     

       5612
        
       

     

       5613
        
         wrapCCMulti = cc:

     

       5614
       +
           if system == "x86_64-linux" then let

     

       5615
       +
             # Binutils with glibc multi

     

       5616
       +
             bintools = cc.bintools.override {

     

       5617
       +
               libc = glibc_multi;

     

       5618
       +
             };

     

       5619
       +
           in lowPrio (wrapCCWith {

     

       5620
        
             cc = cc.cc.override {

     

       5621
        
               stdenv = overrideCC stdenv (wrapCCWith {

     

       5622
        
                 cc = cc.cc;

     

       5623
       +
                 inherit bintools;

     

       5624
        
                 libc = glibc_multi;

     

       5625
        
               });

     

       5626
        
               profiledCompiler = false;

     

       5627
        
               enableMultilib = true;

     

       5628
        
             };

     

       0
        
       
     

       5629
        
             libc = glibc_multi;

     

       5630
       +
             inherit bintools;

     

       5631
        
             extraBuildCommands = ''

     

       5632
        
               echo "dontMoveLib64=1" >> $out/nix-support/setup-hook

     

       5633
        
             '';

     

       5634
        
         }) else throw "Multilib ${cc.name} not supported on ‘${system}’";

     

       5635
        
       

     

       5636
       +
         wrapClangMulti = clang:

     

       5637
       +
           if system == "x86_64-linux" then

     

       5638
       +
             callPackage ../development/compilers/llvm/multi.nix {

     

       5639
       +
               inherit clang;

     

       5640
       +
               gcc32 = pkgsi686Linux.gcc;

     

       5641
       +
               gcc64 = pkgs.gcc;

     

       5642
       +
             }

     

       5643
       +
           else throw "Multilib ${clang.cc.name} not supported on '${system}'";

     

       5644
       +
       

     

       5645
        
         gcc_multi = wrapCCMulti gcc;

     

       5646
       +
         clang_multi = wrapClangMulti clang;

     

       5647
       +
       

     

       5648
       +
         gccMultiStdenv = overrideCC stdenv gcc_multi;

     

       5649
       +
         clangMultiStdenv = overrideCC stdenv clang_multi;

     

       5650
        
       

     

       5651
        
         gcc_debug = lowPrio (wrapCC (gcc.cc.override {

     

       5652
        
           stripped = false;

     
···

       5673
        
             if targetPlatform.libc == "msvcrt" then targetPackages.windows.mingw_w64_headers

     

       5674
        
             else if targetPlatform.libc == "libSystem" then darwin.xcode

     

       5675
        
             else null;

     

       5676
       +
           binutils1 = wrapBintoolsWith {

     

       5677
       +
             bintools = binutils-unwrapped;

     

       5678
       +
             libc = libcCross1;

     

       5679
       +
           };

     

       5680
        
           in wrapCCWith {

     

       5681
        
             name = "gcc-cross-wrapper";

     

       5682
        
             cc = gccFun {

     
···

       5690
        
               crossStageStatic = true;

     

       5691
        
               langCC = false;

     

       5692
        
               libcCross = libcCross1;

     

       5693
       +
               targetPackages.stdenv.cc.bintools = binutils1;

     

       5694
        
               enableShared = false;

     

       5695
        
             };

     

       5696
       +
             bintools = binutils1;

     

       5697
        
             libc = libcCross1;

     

       5698
        
         };

     

       5699
        
       

     
···

       5702
        
           name = "gcc-cross-wrapper";

     

       5703
        
           cc = gccCrossStageStatic.gcc;

     

       5704
        
           libc = windows.mingw_headers2;

     

       5705
       +
           inherit binutils;

     

       5706
        
         };

     

       5707
        
       

     

       5708
        
         gcc45 = lowPrio (wrapCC (callPackage ../development/compilers/gcc/4.5 {

     
···

       6465
        
       

     

       6466
        
         wla-dx = callPackage ../development/compilers/wla-dx { };

     

       6467
        
       

     

       6468
       +
         wrapCCWith = { name ? "", cc, bintools, libc, extraBuildCommands ? "" }:

     

       6469
       +
             ccWrapperFun rec {

     

       6470
        
           nativeTools = targetPlatform == hostPlatform && stdenv.cc.nativeTools or false;

     

       6471
        
           nativeLibc = targetPlatform == hostPlatform && stdenv.cc.nativeLibc or false;

     

       6472
        
           nativePrefix = stdenv.cc.nativePrefix or "";

     
···

       6475
        
           isGNU = cc.isGNU or false;

     

       6476
        
           isClang = cc.isClang or false;

     

       6477
        
       

     

       6478
       +
           inherit name cc bintools libc extraBuildCommands;

     

       6479
        
         };

     

       6480
        
       

     

       6481
        
         ccWrapperFun = callPackage ../build-support/cc-wrapper;

     

       6482
       +
         bintoolsWrapperFun = callPackage ../build-support/bintools-wrapper;

     

       6483
        
       

     

       6484
        
         wrapCC = cc: wrapCCWith {

     

       6485
        
           name = lib.optionalString (targetPlatform != hostPlatform) "gcc-cross-wrapper";

     

       6486
        
           inherit cc;

     

       6487
       +
           # This should be the only bintools runtime dep with this sort of logic. The

     

       6488
       +
           # Others should instead delegate to the next stage's choice with

     

       6489
       +
           # `targetPackages.stdenv.cc.bintools`. This one is different just to

     

       6490
       +
           # provide the default choice, avoiding infinite recursion.

     

       6491
       +
           bintools = if targetPlatform.isDarwin then darwin.binutils else binutils;

     

       6492
        
           libc = if targetPlatform != hostPlatform then libcCross else stdenv.cc.libc;

     

       6493
        
         };

     

       6494
        
         # legacy version, used for gnat bootstrapping

     
···

       6498
        
           nativePrefix = stdenv.cc.nativePrefix or "";

     

       6499
        
           gcc = baseGCC;

     

       6500
        
           libc = glibc;

     

       6501
       +
         };

     

       6502
       +
       

     

       6503
       +
         wrapBintoolsWith = { bintools, libc }: bintoolsWrapperFun {

     

       6504
       +
           nativeTools = targetPlatform == hostPlatform && stdenv.cc.nativeTools or false;

     

       6505
       +
           nativeLibc = targetPlatform == hostPlatform && stdenv.cc.nativeLibc or false;

     

       6506
       +
           nativePrefix = stdenv.cc.nativePrefix or "";

     

       6507
       +
       

     

       6508
       +
           noLibc = (libc == null);

     

       6509
       +
       

     

       6510
       +
           inherit bintools libc;

     

       6511
       +
           extraBuildCommands = "";

     

       6512
        
         };

     

       6513
        
       

     

       6514
        
         # prolog

     
···

       7092
        
           then darwin.binutils

     

       7093
        
           else binutils-raw;

     

       7094
        
       

     

       7095
       +
         binutils-unwrapped = callPackage ../development/tools/misc/binutils {

     

       7096
        
           # FHS sys dirs presumably only have stuff for the build platform

     

       7097
        
           noSysDirs = (targetPlatform != buildPlatform) || noSysDirs;

     

       7098
        
         };

     

       7099
       +
         binutils-raw = wrapBintoolsWith {

     

       7100
       +
           libc = if targetPlatform != hostPlatform then libcCross else stdenv.cc.libc;

     

       7101
       +
           bintools = binutils-unwrapped;

     

       7102
       +
         };

     

       7103
        
       

     

       7104
        
         binutils_nogold = lowPrio (binutils-raw.override {

     

       7105
       +
           bintools = binutils-raw.bintools.override {

     

       7106
       +
             gold = false;

     

       7107
       +
           };

     

       7108
        
         });

     

       7109
        
       

     

       7110
        
         bison2 = callPackage ../development/tools/parsing/bison/2.x.nix { };

     
···

       9841
        
       

     

       9842
        
         libva = callPackage ../development/libraries/libva { };

     

       9843
        
         libva-full = libva.override { minimal = false; };

     

       9844
       +
         libva-utils = callPackage ../development/libraries/libva-utils { };

     

       9845
        
       

     

       9846
        
         libvdpau = callPackage ../development/libraries/libvdpau { };

     

       9847
        
       

     
···

       20088
        
           cc-wrapper-clang-5 = callPackage ../test/cc-wrapper { stdenv = llvmPackages_5.stdenv; };

     

       20089
        
           cc-wrapper-libcxx-5 = callPackage ../test/cc-wrapper { stdenv = llvmPackages_5.libcxxStdenv; };

     

       20090
        
           stdenv-inputs = callPackage ../test/stdenv-inputs { };

     

       20091
       +
       

     

       20092
       +
           cc-multilib-gcc = callPackage ../test/cc-wrapper/multilib.nix { stdenv = gccMultiStdenv; };

     

       20093
       +
           cc-multilib-clang = callPackage ../test/cc-wrapper/multilib.nix { stdenv = clangMultiStdenv; };

     

       20094
        
       

     

       20095
        
           macOSSierraShared = callPackage ../test/macos-sierra-shared {};

     

       20096
        
         };

+8 -2

pkgs/top-level/darwin-packages.nix

···

       10
        
       

     

       11
        
         apple_sdk = callPackage ../os-specific/darwin/apple-sdk { };

     

       12
        
       

     

       13
       -
         binutils = callPackage ../os-specific/darwin/binutils {

     

       14
       -
           inherit (darwin) cctools;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
         };

     

       16
        
       

     

       17
        
         cctools = callPackage ../os-specific/darwin/cctools/port.nix {

···

       10
        
       

     

       11
        
         apple_sdk = callPackage ../os-specific/darwin/apple-sdk { };

     

       12
        
       

     

       13
       +
         binutils = pkgs.wrapBintoolsWith {

     

       14
       +
           libc =

     

       15
       +
             if pkgs.targetPlatform != pkgs.hostPlatform

     

       16
       +
             then pkgs.libcCross

     

       17
       +
             else pkgs.stdenv.cc.libc;

     

       18
       +
           bintools = callPackage ../os-specific/darwin/binutils {

     

       19
       +
             inherit (darwin) cctools;

     

       20
       +
           };

     

       21
        
         };

     

       22
        
       

     

       23
        
         cctools = callPackage ../os-specific/darwin/cctools/port.nix {

pkgs/top-level/perl-packages.nix

···

       4849
        
             url = "mirror://cpan/authors/id/J/JG/JGMYERS/${name}.tar.gz";

     

       4850
        
             sha256 = "834d893aa7db6ce3f158afbd0e432d6ed15a276e0940db0a74be13fd9c4bbbf1";

     

       4851
        
           };

     

       0
        
       
     

       4852
        
           propagatedBuildInputs = [ ModuleBuild ];

     

       4853
        
           meta = {

     

       4854
        
             description = "An Encode::Encoding subclass that detects the encoding of data";

     
···

       5162
        
             url = "mirror://cpan/modules/by-module/ExtUtils/${name}.tar.gz";

     

       5163
        
             sha256 = "1a77hxf2pa8ia9na72rijv1yhpn2bjrdsybwk2dj2l938pl3xn0w";

     

       5164
        
           };

     

       0
        
       
     

       5165
        
           propagatedBuildInputs = [ CaptureTiny ];

     

       5166
        
         };

     

       5167
        
       

     
···

       8488
        
             url = "mirror://cpan/modules/by-module/Math/${name}.tar.gz";

     

       8489
        
             sha256 = "0i9wzvig7ayijc9nvh5x5rryk1jrcj1hcvfmlcj449rnnxx24dav";

     

       8490
        
           };

     

       0
        
       
     

       8491
        
           propagatedBuildInputs = [ ModuleBuildWithXSpp ExtUtilsXSpp ExtUtilsTypemapsDefault TestDeep ];

     

       8492
        
         };

     

       8493

···

       4849
        
             url = "mirror://cpan/authors/id/J/JG/JGMYERS/${name}.tar.gz";

     

       4850
        
             sha256 = "834d893aa7db6ce3f158afbd0e432d6ed15a276e0940db0a74be13fd9c4bbbf1";

     

       4851
        
           };

     

       4852
       +
           nativeBuildInputs = [ pkgs.ld-is-cc-hook ];

     

       4853
        
           propagatedBuildInputs = [ ModuleBuild ];

     

       4854
        
           meta = {

     

       4855
        
             description = "An Encode::Encoding subclass that detects the encoding of data";

     
···

       5163
        
             url = "mirror://cpan/modules/by-module/ExtUtils/${name}.tar.gz";

     

       5164
        
             sha256 = "1a77hxf2pa8ia9na72rijv1yhpn2bjrdsybwk2dj2l938pl3xn0w";

     

       5165
        
           };

     

       5166
       +
           nativeBuildInputs = [ pkgs.ld-is-cc-hook ];

     

       5167
        
           propagatedBuildInputs = [ CaptureTiny ];

     

       5168
        
         };

     

       5169
        
       

     
···

       8490
        
             url = "mirror://cpan/modules/by-module/Math/${name}.tar.gz";

     

       8491
        
             sha256 = "0i9wzvig7ayijc9nvh5x5rryk1jrcj1hcvfmlcj449rnnxx24dav";

     

       8492
        
           };

     

       8493
       +
           nativeBuildInputs = [ pkgs.ld-is-cc-hook ];

     

       8494
        
           propagatedBuildInputs = [ ModuleBuildWithXSpp ExtUtilsXSpp ExtUtilsTypemapsDefault TestDeep ];

     

       8495
        
         };

     

       8496

+7 -10

pkgs/top-level/python-packages.nix

···

       56
        
           flit = self.flit;

     

       57
        
           # We want Python libraries to be named like e.g. "python3.6-${name}"

     

       58
        
           inherit namePrefix;

     

       59
       -
           pythonModule = python;

     

       60
        
         }));

     

       61
        
       

     

       62
        
         buildPythonApplication = makeOverridablePythonPackage ( makeOverridable (callPackage ../development/interpreters/python/build-python-package.nix {

     

       63
        
           inherit bootstrapped-pip;

     

       64
        
           flit = self.flit;

     

       65
        
           namePrefix = "";

     

       66
       -
           pythonModule = false;

     

       67
        
         }));

     

       68
        
       

     

       69
        
         graphiteVersion = "1.0.2";

     
···

       87
        
           in fetcher (builtins.removeAttrs attrs ["format"]) );

     

       88
        
       

     

       89
        
         # Check whether a derivation provides a Python module.

     

       90
       -
         hasPythonModule = drv: (hasAttr "pythonModule" drv) && ( (getAttr "pythonModule" drv) == python);

     

       91
        
       

     

       92
        
         # Get list of required Python modules given a list of derivations.

     

       93
        
         requiredPythonModules = drvs: let

     

       94
       -
           filterNull = list: filter (x: !isNull x) list;

     

       95
       -
           conditionalGetRecurse = attr: condition: drv: let f = conditionalGetRecurse attr condition; in

     

       96
       -
             (if (condition drv) then unique [drv]++(concatMap f (filterNull(getAttr attr drv))) else []);

     

       97
       -
           _required = drv: conditionalGetRecurse "propagatedBuildInputs" hasPythonModule drv;

     

       98
       -
         in [python] ++ (unique (concatMap _required (filterNull drvs)));

     

       99
        
       

     

       100
        
         # Create a PYTHONPATH from a list of derivations. This function recurses into the items to find derivations

     

       101
        
         # providing Python modules.

     
···

       106
        
           drv.overrideAttrs( oldAttrs: {

     

       107
        
             # Use passthru in order to prevent rebuilds when possible.

     

       108
        
             passthru = (oldAttrs.passthru or {})// {

     

       109
       -
               name = namePrefix + oldAttrs.name;

     

       110
        
               pythonModule = python;

     

       111
        
               pythonPath = [ ]; # Deprecated, for compatibility.

     

       0
        
       
     

       112
        
             };

     

       113
        
           });

     

       114
        
       

     
···

       129
        
       

     

       130
        
         recursivePthLoader = callPackage ../development/python-modules/recursive-pth-loader { };

     

       131
        
       

     

       132
       -
         setuptools = callPackage ../development/python-modules/setuptools { };

     

       133
        
       

     

       134
        
         vowpalwabbit = callPackage ../development/python-modules/vowpalwabbit {

     

       135
        
           pythonPackages = self;

···

       56
        
           flit = self.flit;

     

       57
        
           # We want Python libraries to be named like e.g. "python3.6-${name}"

     

       58
        
           inherit namePrefix;

     

       59
       +
           inherit toPythonModule;

     

       60
        
         }));

     

       61
        
       

     

       62
        
         buildPythonApplication = makeOverridablePythonPackage ( makeOverridable (callPackage ../development/interpreters/python/build-python-package.nix {

     

       63
        
           inherit bootstrapped-pip;

     

       64
        
           flit = self.flit;

     

       65
        
           namePrefix = "";

     

       66
       +
           toPythonModule = x: x; # Application does not provide modules.

     

       67
        
         }));

     

       68
        
       

     

       69
        
         graphiteVersion = "1.0.2";

     
···

       87
        
           in fetcher (builtins.removeAttrs attrs ["format"]) );

     

       88
        
       

     

       89
        
         # Check whether a derivation provides a Python module.

     

       90
       +
         hasPythonModule = drv: drv?pythonModule && drv.pythonModule == python;

     

       91
        
       

     

       92
        
         # Get list of required Python modules given a list of derivations.

     

       93
        
         requiredPythonModules = drvs: let

     

       94
       +
           modules = filter hasPythonModule drvs;

     

       95
       +
         in unique ([python] ++ modules ++ concatLists (catAttrs "requiredPythonModules" modules));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       96
        
       

     

       97
        
         # Create a PYTHONPATH from a list of derivations. This function recurses into the items to find derivations

     

       98
        
         # providing Python modules.

     
···

       103
        
           drv.overrideAttrs( oldAttrs: {

     

       104
        
             # Use passthru in order to prevent rebuilds when possible.

     

       105
        
             passthru = (oldAttrs.passthru or {})// {

     

       0
        
       
     

       106
        
               pythonModule = python;

     

       107
        
               pythonPath = [ ]; # Deprecated, for compatibility.

     

       108
       +
               requiredPythonModules = requiredPythonModules drv.propagatedBuildInputs;

     

       109
        
             };

     

       110
        
           });

     

       111
        
       

     
···

       126
        
       

     

       127
        
         recursivePthLoader = callPackage ../development/python-modules/recursive-pth-loader { };

     

       128
        
       

     

       129
       +
         setuptools = toPythonModule (callPackage ../development/python-modules/setuptools { });

     

       130
        
       

     

       131
        
         vowpalwabbit = callPackage ../development/python-modules/vowpalwabbit {

     

       132
        
           pythonPackages = self;

pkgs/top-level/release.nix

···

       112
        
                     jobs.tests.cc-wrapper-clang-39.x86_64-darwin

     

       113
        
                     jobs.tests.cc-wrapper-libcxx-39.x86_64-linux

     

       114
        
                     jobs.tests.cc-wrapper-libcxx-39.x86_64-darwin

     

       0
        
       
     

       0
        
       
     

       115
        
                     jobs.tests.stdenv-inputs.x86_64-linux

     

       116
        
                     jobs.tests.stdenv-inputs.x86_64-darwin

     

       117
        
                     jobs.tests.macOSSierraShared.x86_64-darwin

···

       112
        
                     jobs.tests.cc-wrapper-clang-39.x86_64-darwin

     

       113
        
                     jobs.tests.cc-wrapper-libcxx-39.x86_64-linux

     

       114
        
                     jobs.tests.cc-wrapper-libcxx-39.x86_64-darwin

     

       115
       +
                     jobs.tests.cc-multilib-gcc.x86_64-linux

     

       116
       +
                     jobs.tests.cc-multilib-clang.x86_64-linux

     

       117
        
                     jobs.tests.stdenv-inputs.x86_64-linux

     

       118
        
                     jobs.tests.stdenv-inputs.x86_64-darwin

     

       119
        
                     jobs.tests.macOSSierraShared.x86_64-darwin