commit 20e756a0936fb75ce8f9d9ef0b7a511198bf7eea · pyrox.dev/nixpkgs

+44 -8

doc/cross-compilation.xml

···

       85
       85
        
             This field is obsolete and will soon disappear—please do not use it.

     

       86
       86
        
           </para></note>

     

       87
       87
        
           <para>

     

       88
       88
       -
             The exact scheme these fields is a bit ill-defined due to a long and convoluted evolution, but this is slowly being cleaned up.

     

       88
       88
       +
             The exact schema these fields follow is a bit ill-defined due to a long and convoluted evolution, but this is slowly being cleaned up.

     

       89
       89
       +
             You can see examples of ones used in practice in <literal>lib.systems.examples</literal>; note how they are not all very consistent.

     

       89
       90
        
             For now, here are few fields can count on them containing:

     

       90
       91
        
           </para>

     

       91
       92
        
           <variablelist>

     
···

       118
       119
        
                   This is a nix representation of a parsed LLVM target triple with white-listed components.

     

       119
       120
        
                   This can be specified directly, or actually parsed from the <varname>config</varname>.

     

       120
       121
        
                   [Technically, only one need be specified and the others can be inferred, though the precision of inference may not be very good.]

     

       121
       121
       -
                   See <literal>lib.systems.parse</literal> for the exact representation, along with some <literal>is*</literal>predicates.

     

       122
       122
       -
                   These predicates are superior to the ones in <varname>stdenv</varname> as they aren't tied to the build platform (host, as previously discussed, would be a saner default).

     

       122
       122
       +
                   See <literal>lib.systems.parse</literal> for the exact representation.

     

       123
       123
       +
                 </para>

     

       124
       124
       +
               </listitem>

     

       125
       125
       +
             </varlistentry>

     

       126
       126
       +
             <varlistentry>

     

       127
       127
       +
               <term><varname>libc</varname></term>

     

       128
       128
       +
               <listitem>

     

       129
       129
       +
                 <para>

     

       130
       130
       +
                   This is a string identifying the standard C library used.

     

       131
       131
       +
                   Valid identifiers include "glibc" for GNU libc, "libsystem" for Darwin's Libsystem, and "uclibc" for µClibc.

     

       132
       132
       +
                   It should probably be refactored to use the module system, like <varname>parse</varname>.

     

       133
       133
       +
                 </para>

     

       134
       134
       +
               </listitem>

     

       135
       135
       +
             </varlistentry>

     

       136
       136
       +
             <varlistentry>

     

       137
       137
       +
               <term><varname>is*</varname></term>

     

       138
       138
       +
               <listitem>

     

       139
       139
       +
                 <para>

     

       140
       140
       +
                   These predicates are defined in <literal>lib.systems.inspect</literal>, and slapped on every platform.

     

       141
       141
       +
                   They are superior to the ones in <varname>stdenv</varname> as they force the user to be explicit about which platform they are inspecting.

     

       142
       142
       +
                   Please use these instead of those.

     

       123
       143
        
                 </para>

     

       124
       144
        
               </listitem>

     

       125
       145
        
             </varlistentry>

     
···

       128
       148
        
               <listitem>

     

       129
       149
        
                 <para>

     

       130
       150
        
                   This is, quite frankly, a dumping ground of ad-hoc settings (it's an attribute set).

     

       131
       131
       -
                   See <literal>lib.systems.platforms</literal> for examples—there's hopefully one in there that will work verbatim for each platform one is working.

     

       151
       151
       +
                   See <literal>lib.systems.platforms</literal> for examples—there's hopefully one in there that will work verbatim for each platform that is working.

     

       132
       152
        
                   Please help us triage these flags and give them better homes!

     

       133
       153
        
                 </para>

     

       134
       154
        
               </listitem>

     
···

       184
       204
        
           More information needs to moved from the old wiki, especially <link xlink:href="https://nixos.org/wiki/CrossCompiling" />, for this section.

     

       185
       205
        
         </para></note>

     

       186
       206
        
         <para>

     

       187
       187
       -
           Many sources (manual, wiki, etc) probably mention passing <varname>system</varname>, <varname>platform</varname>, and, optionally, <varname>crossSystem</varname> to nixpkgs:

     

       188
       188
       -
           <literal>import &lt;nixpkgs&gt; { system = ..; platform = ..; crossSystem = ..; }</literal>.

     

       189
       189
       -
           <varname>system</varname> and <varname>platform</varname> together determine the system on which packages are built, and <varname>crossSystem</varname> specifies the platform on which packages are ultimately intended to run, if it is different.

     

       190
       190
       -
           This still works, but with more recent changes, one can alternatively pass <varname>localSystem</varname>, containing <varname>system</varname> and <varname>platform</varname>, for symmetry.

     

       207
       207
       +
           Nixpkgs can be instantiated with <varname>localSystem</varname> alone, in which case there is no cross compiling and everything is built by and for that system,

     

       208
       208
       +
           or also with <varname>crossSystem</varname>, in which case packages run on the latter, but all building happens on the former.

     

       209
       209
       +
           Both parameters take the same schema as the 3 (build, host, and target) platforms defined in the previous section.

     

       210
       210
       +
           As mentioned above, <literal>lib.systems.examples</literal> has some platforms which are used as arguments for these parameters in practice.

     

       211
       211
       +
           You can use them programmatically, or on the command line like <command>nix-build &lt;nixpkgs&gt; --arg crossSystem '(import &lt;nixpkgs/lib&gt;).systems.examples.fooBarBaz'</command>.

     

       191
       212
        
         </para>

     

       213
       213
       +
         <para>

     

       214
       214
       +
           While one is free to pass both parameters in full, there's a lot of logic to fill in missing fields.

     

       215
       215
       +
           As discussed in the previous section, only one of <varname>system</varname>, <varname>config</varname>, and <varname>parsed</varname> is needed to infer the other two.

     

       216
       216
       +
           Additionally, <varname>libc</varname> will be inferred from <varname>parse</varname>.

     

       217
       217
       +
           Finally, <literal>localSystem.system</literal> is also <emphasis>impurely</emphasis> inferred based on the platform evaluation occurs.

     

       218
       218
       +
           This means it is often not necessary to pass <varname>localSystem</varname> at all, as in the command-line example in the previous paragraph.

     

       219
       219
       +
         </para>

     

       220
       220
       +
         <note>

     

       221
       221
       +
           <para>

     

       222
       222
       +
             Many sources (manual, wiki, etc) probably mention passing <varname>system</varname>, <varname>platform</varname>, along with the optional <varname>crossSystem</varname> to nixpkgs:

     

       223
       223
       +
             <literal>import &lt;nixpkgs&gt; { system = ..; platform = ..; crossSystem = ..; }</literal>.

     

       224
       224
       +
             Passing those two instead of <varname>localSystem</varname> is still supported for compatibility, but is discouraged.

     

       225
       225
       +
             Indeed, much of the inference we do for these parameters is motivated by compatibility as much as convenience.

     

       226
       226
       +
           </para>

     

       227
       227
       +
         </note>

     

       192
       228
        
         <para>

     

       193
       229
        
           One would think that <varname>localSystem</varname> and <varname>crossSystem</varname> overlap horribly with the three <varname>*Platforms</varname> (<varname>buildPlatform</varname>, <varname>hostPlatform,</varname> and <varname>targetPlatform</varname>; see <varname>stage.nix</varname> or the manual).

     

       194
       230
        
           Actually, those identifiers are purposefully not used here to draw a subtle but important distinction:

lib/systems/default.nix

···

       5
       5
        
         parse = import ./parse.nix;

     

       6
       6
        
         inspect = import ./inspect.nix;

     

       7
       7
        
         platforms = import ./platforms.nix;

     

       8
       8
       +
         examples = import ./examples.nix;

     

       8
       9
        
       

     

       9
       10
        
         # Elaborate a `localSystem` or `crossSystem` so that it contains everything

     

       10
       11
        
         # necessary.

+130

lib/systems/examples.nix

···

       1
       1
       +
       # These can be passed to nixpkgs as either the `localSystem` or

     

       2
       2
       +
       # `crossSystem`. They are put here for user convenience, but also used by cross

     

       3
       3
       +
       # tests and linux cross stdenv building, so handle with care!

     

       4
       4
       +
       

     

       5
       5
       +
       let platforms = import ./platforms.nix; in

     

       6
       6
       +
       

     

       7
       7
       +
       rec {

     

       8
       8
       +
         #

     

       9
       9
       +
         # Linux

     

       10
       10
       +
         #

     

       11
       11
       +
       

     

       12
       12
       +
         sheevaplug = rec {

     

       13
       13
       +
           config = "armv5te-unknown-linux-gnueabi";

     

       14
       14
       +
           bigEndian = false;

     

       15
       15
       +
           arch = "armv5te";

     

       16
       16
       +
           float = "soft";

     

       17
       17
       +
           withTLS = true;

     

       18
       18
       +
           libc = "glibc";

     

       19
       19
       +
           platform = platforms.sheevaplug;

     

       20
       20
       +
           openssl.system = "linux-generic32";

     

       21
       21
       +
           inherit (platform) gcc;

     

       22
       22
       +
         };

     

       23
       23
       +
       

     

       24
       24
       +
         raspberryPi = rec {

     

       25
       25
       +
           config = "armv6l-unknown-linux-gnueabihf";

     

       26
       26
       +
           bigEndian = false;

     

       27
       27
       +
           arch = "armv6l";

     

       28
       28
       +
           float = "hard";

     

       29
       29
       +
           fpu = "vfp";

     

       30
       30
       +
           withTLS = true;

     

       31
       31
       +
           libc = "glibc";

     

       32
       32
       +
           platform = platforms.raspberrypi;

     

       33
       33
       +
           openssl.system = "linux-generic32";

     

       34
       34
       +
           inherit (platform) gcc;

     

       35
       35
       +
         };

     

       36
       36
       +
       

     

       37
       37
       +
         armv7l-hf-multiplatform = rec {

     

       38
       38
       +
           config = "arm-unknown-linux-gnueabihf";

     

       39
       39
       +
           bigEndian = false;

     

       40
       40
       +
           arch = "armv7-a";

     

       41
       41
       +
           float = "hard";

     

       42
       42
       +
           fpu = "vfpv3-d16";

     

       43
       43
       +
           withTLS = true;

     

       44
       44
       +
           libc = "glibc";

     

       45
       45
       +
           platform = platforms.armv7l-hf-multiplatform;

     

       46
       46
       +
           openssl.system = "linux-generic32";

     

       47
       47
       +
           inherit (platform) gcc;

     

       48
       48
       +
         };

     

       49
       49
       +
       

     

       50
       50
       +
         aarch64-multiplatform = rec {

     

       51
       51
       +
           config = "aarch64-unknown-linux-gnu";

     

       52
       52
       +
           bigEndian = false;

     

       53
       53
       +
           arch = "aarch64";

     

       54
       54
       +
           withTLS = true;

     

       55
       55
       +
           libc = "glibc";

     

       56
       56
       +
           platform = platforms.aarch64-multiplatform;

     

       57
       57
       +
           inherit (platform) gcc;

     

       58
       58
       +
         };

     

       59
       59
       +
       

     

       60
       60
       +
         scaleway-c1 = armv7l-hf-multiplatform // rec {

     

       61
       61
       +
           platform = platforms.scaleway-c1;

     

       62
       62
       +
           inherit (platform) gcc;

     

       63
       63
       +
           inherit (gcc) fpu;

     

       64
       64
       +
         };

     

       65
       65
       +
       

     

       66
       66
       +
         pogoplug4 = rec {

     

       67
       67
       +
           arch = "armv5tel";

     

       68
       68
       +
           config = "armv5tel-softfloat-linux-gnueabi";

     

       69
       69
       +
           float = "soft";

     

       70
       70
       +
       

     

       71
       71
       +
           platform = platforms.pogoplug4;

     

       72
       72
       +
       

     

       73
       73
       +
           inherit (platform) gcc;

     

       74
       74
       +
           libc = "glibc";

     

       75
       75
       +
       

     

       76
       76
       +
           withTLS = true;

     

       77
       77
       +
           openssl.system = "linux-generic32";

     

       78
       78
       +
         };

     

       79
       79
       +
       

     

       80
       80
       +
         fuloongminipc = rec {

     

       81
       81
       +
           config = "mips64el-unknown-linux-gnu";

     

       82
       82
       +
           bigEndian = false;

     

       83
       83
       +
           arch = "mips";

     

       84
       84
       +
           float = "hard";

     

       85
       85
       +
           withTLS = true;

     

       86
       86
       +
           libc = "glibc";

     

       87
       87
       +
           platform = platforms.fuloong2f_n32;

     

       88
       88
       +
           openssl.system = "linux-generic32";

     

       89
       89
       +
           inherit (platform) gcc;

     

       90
       90
       +
         };

     

       91
       91
       +
       

     

       92
       92
       +
         #

     

       93
       93
       +
         # Darwin

     

       94
       94
       +
         #

     

       95
       95
       +
       

     

       96
       96
       +
         iphone64 = {

     

       97
       97
       +
           config = "aarch64-apple-darwin14";

     

       98
       98
       +
           arch = "arm64";

     

       99
       99
       +
           libc = "libsystem";

     

       100
       100
       +
           platform = {};

     

       101
       101
       +
         };

     

       102
       102
       +
       

     

       103
       103
       +
         iphone32 = {

     

       104
       104
       +
           config = "arm-apple-darwin10";

     

       105
       105
       +
           arch = "armv7-a";

     

       106
       106
       +
           libc = "libsystem";

     

       107
       107
       +
           platform = {};

     

       108
       108
       +
         };

     

       109
       109
       +
       

     

       110
       110
       +
         #

     

       111
       111
       +
         # Windows

     

       112
       112
       +
         #

     

       113
       113
       +
       

     

       114
       114
       +
         # 32 bit mingw-w64

     

       115
       115
       +
         mingw32 = {

     

       116
       116
       +
           config = "i686-pc-mingw32";

     

       117
       117
       +
           arch = "x86"; # Irrelevant

     

       118
       118
       +
           libc = "msvcrt"; # This distinguishes the mingw (non posix) toolchain

     

       119
       119
       +
           platform = {};

     

       120
       120
       +
         };

     

       121
       121
       +
       

     

       122
       122
       +
         # 64 bit mingw-w64

     

       123
       123
       +
         mingwW64 = {

     

       124
       124
       +
           # That's the triplet they use in the mingw-w64 docs.

     

       125
       125
       +
           config = "x86_64-pc-mingw32";

     

       126
       126
       +
           arch = "x86_64"; # Irrelevant

     

       127
       127
       +
           libc = "msvcrt"; # This distinguishes the mingw (non posix) toolchain

     

       128
       128
       +
           platform = {};

     

       129
       129
       +
         };

     

       130
       130
       +
       }

+8 -1

lib/systems/platforms.nix

···

       255
       255
        
             arch = "armv6";

     

       256
       256
        
             fpu = "vfp";

     

       257
       257
        
             float = "hard";

     

       258
       258
       +
             # TODO(@Ericson2314) what is this and is it a good idea? It was

     

       259
       259
       +
             # used in some cross compilation examples but not others.

     

       260
       260
       +
             #

     

       261
       261
       +
             # abi = "aapcs-linux";

     

       258
       262
        
           };

     

       259
       263
        
         };

     

       260
       264
        
       

     
···

       460
       464
        
           '';

     

       461
       465
        
           kernelTarget = "vmlinux";

     

       462
       466
        
           uboot = null;

     

       463
       463
       -
           gcc.arch = "loongson2f";

     

       467
       467
       +
           gcc = {

     

       468
       468
       +
             arch = "loongson2f";

     

       469
       469
       +
             abi = "n32";

     

       470
       470
       +
           };

     

       464
       471
        
         };

     

       465
       472
        
       

     

       466
       473
        
         beaglebone = armv7l-hf-multiplatform // {

+10 -82

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

···

       6
       6
        
         lib = import ../../../lib;

     

       7
       7
        
         pkgsFun = import ../../..;

     

       8
       8
        
       

     

       9
       9
       -
         sheevaplugCrossSystem = {

     

       10
       10
       -
           crossSystem = rec {

     

       11
       11
       -
             config = "arm-linux-gnueabi";

     

       12
       12
       -
             bigEndian = false;

     

       13
       13
       -
             arch = "armv5te";

     

       14
       14
       -
             float = "soft";

     

       15
       15
       -
             withTLS = true;

     

       16
       16
       -
             libc = "glibc";

     

       17
       17
       -
             platform = lib.systems.platforms.sheevaplug;

     

       18
       18
       -
             openssl.system = "linux-generic32";

     

       19
       19
       -
             inherit (platform) gcc;

     

       20
       20
       -
           };

     

       21
       21
       -
         };

     

       22
       22
       -
       

     

       23
       23
       -
         raspberrypiCrossSystem = {

     

       24
       24
       -
           crossSystem = rec {

     

       25
       25
       -
             config = "arm-linux-gnueabihf";

     

       26
       26
       -
             bigEndian = false;

     

       27
       27
       -
             arch = "armv6";

     

       28
       28
       -
             float = "hard";

     

       29
       29
       -
             fpu = "vfp";

     

       30
       30
       -
             withTLS = true;

     

       31
       31
       -
             libc = "glibc";

     

       32
       32
       -
             platform = lib.systems.platforms.raspberrypi;

     

       33
       33
       -
             openssl.system = "linux-generic32";

     

       34
       34
       -
             inherit (platform) gcc;

     

       35
       35
       -
           };

     

       36
       36
       -
         };

     

       37
       37
       -
       

     

       38
       38
       -
         armv7l-hf-multiplatform-crossSystem = {

     

       39
       39
       -
           crossSystem = rec {

     

       40
       40
       -
             config = "arm-linux-gnueabihf";

     

       41
       41
       -
             bigEndian = false;

     

       42
       42
       -
             arch = "armv7-a";

     

       43
       43
       -
             float = "hard";

     

       44
       44
       -
             fpu = "vfpv3-d16";

     

       45
       45
       -
             withTLS = true;

     

       46
       46
       -
             libc = "glibc";

     

       47
       47
       -
             platform = lib.systems.platforms.armv7l-hf-multiplatform;

     

       48
       48
       -
             openssl.system = "linux-generic32";

     

       49
       49
       -
             inherit (platform) gcc;

     

       50
       50
       -
           };

     

       51
       51
       -
         };

     

       52
       52
       -
       

     

       53
       53
       -
         aarch64-multiplatform-crossSystem = {

     

       54
       54
       -
           crossSystem = rec {

     

       55
       55
       -
             config = "aarch64-linux-gnu";

     

       56
       56
       -
             bigEndian = false;

     

       57
       57
       -
             arch = "aarch64";

     

       58
       58
       -
             withTLS = true;

     

       59
       59
       -
             libc = "glibc";

     

       60
       60
       -
             platform = lib.systems.platforms.aarch64-multiplatform;

     

       61
       61
       -
             inherit (platform) gcc;

     

       62
       62
       -
           };

     

       63
       63
       -
         };

     

       64
       64
       -
       

     

       65
       65
       -
         scaleway-c1-crossSystem.crossSystem = armv7l-hf-multiplatform-crossSystem.crossSystem // rec {

     

       66
       66
       -
           platform = lib.systems.platforms.scaleway-c1;

     

       67
       67
       -
           inherit (platform) gcc;

     

       68
       68
       -
           inherit (gcc) fpu;

     

       69
       69
       -
         };

     

       70
       70
       -
       

     

       71
       71
       -
         pogoplug4-crossSystem.crossSystem = {

     

       72
       72
       -
           arch = "armv5tel";

     

       73
       73
       -
           config = "armv5tel-softfloat-linux-gnueabi";

     

       74
       74
       -
           float = "soft";

     

       75
       75
       -
       

     

       76
       76
       -
           platform = lib.systems.platforms.pogoplug4;

     

       77
       77
       -
       

     

       78
       78
       -
           inherit (lib.systems.platforms.pogoplug4) gcc;

     

       79
       79
       -
           libc = "glibc";

     

       80
       80
       -
       

     

       81
       81
       -
           withTLS = true;

     

       82
       82
       -
           openssl.system = "linux-generic32";

     

       83
       83
       -
         };

     

       9
       9
       +
         inherit (lib.systems.examples)

     

       10
       10
       +
           sheevaplug raspberryPi armv7l-hf-multiplatform

     

       11
       11
       +
           aarch64-multiplatform scaleway-c1 pogoplug4;

     

       84
       12
        
       

     

       85
       13
        
         selectedCrossSystem =

     

       86
       86
       -
           if toolsArch == "armv5tel" then sheevaplugCrossSystem else

     

       87
       87
       -
           if toolsArch == "scaleway" then scaleway-c1-crossSystem else

     

       88
       88
       -
           if toolsArch == "pogoplug4" then pogoplug4-crossSystem else

     

       89
       89
       -
           if toolsArch == "armv6l" then raspberrypiCrossSystem else

     

       90
       90
       -
           if toolsArch == "armv7l" then armv7l-hf-multiplatform-crossSystem else

     

       91
       91
       -
           if toolsArch == "aarch64" then aarch64-multiplatform-crossSystem else null;

     

       14
       14
       +
           if toolsArch == "armv5tel" then sheevaplug else

     

       15
       15
       +
           if toolsArch == "scaleway" then scaleway-c1 else

     

       16
       16
       +
           if toolsArch == "pogoplug4" then pogoplug4 else

     

       17
       17
       +
           if toolsArch == "armv6l" then raspberryPi else

     

       18
       18
       +
           if toolsArch == "armv7l" then armv7l-hf-multiplatform else

     

       19
       19
       +
           if toolsArch == "aarch64" then aarch64-multiplatform else null;

     

       92
       20
        
       

     

       93
       93
       -
         pkgs = pkgsFun ({inherit system;} // selectedCrossSystem);

     

       21
       21
       +
         pkgs = pkgsFun ({ inherit system; crossSystem = selectedCrossSystem; });

     

       94
       22
        
       

     

       95
       23
        
         glibc = pkgs.libcCross;

     

       96
       24
        
         bash = pkgs.bash;

+7 -82

pkgs/top-level/release-cross.nix

···

       89
       89
        
           guile = nativePlatforms;

     

       90
       90
        
         };

     

       91
       91
        
       

     

       92
       92
       -
         darwinToAarch64 = let

     

       93
       93
       -
           crossSystem = {

     

       94
       94
       -
             config = "aarch64-apple-darwin14";

     

       95
       95
       -
             arch = "arm64";

     

       96
       96
       -
             libc = "libSystem";

     

       97
       97
       -
           };

     

       98
       98
       -
         in mapTestOnCross crossSystem darwinCommon;

     

       92
       92
       +
         crossIphone64 = mapTestOnCross lib.systems.examples.iphone64 darwinCommon;

     

       99
       93
        
       

     

       100
       100
       -
         darwinToArm = let

     

       101
       101
       -
           crossSystem = {

     

       102
       102
       -
             config = "arm-apple-darwin10";

     

       103
       103
       -
             arch = "armv7-a";

     

       104
       104
       -
             libc = "libSystem";

     

       105
       105
       -
           };

     

       106
       106
       -
         in mapTestOnCross crossSystem darwinCommon;

     

       94
       94
       +
         crossIphone32 = mapTestOnCross lib.systems.examples.iphone32 darwinCommon;

     

       107
       95
        
       

     

       108
       96
        
         /* Test some cross builds to the Sheevaplug */

     

       109
       109
       -
         crossSheevaplugLinux = let

     

       110
       110
       -
           crossSystem = {

     

       111
       111
       -
             config = "armv5tel-unknown-linux-gnueabi";

     

       112
       112
       -
             bigEndian = false;

     

       113
       113
       -
             arch = "arm";

     

       114
       114
       -
             float = "soft";

     

       115
       115
       -
             withTLS = true;

     

       116
       116
       -
             platform = lib.systems.platforms.sheevaplug;

     

       117
       117
       -
             libc = "glibc";

     

       118
       118
       -
             openssl.system = "linux-generic32";

     

       119
       119
       -
           };

     

       120
       120
       -
         in mapTestOnCross crossSystem (linuxCommon // {

     

       97
       97
       +
         crossSheevaplugLinux = mapTestOnCross lib.systems.examples.sheevaplug (linuxCommon // {

     

       121
       98
        
           ubootSheevaplug = nativePlatforms;

     

       122
       99
        
         });

     

       123
       100
        
       

     

       124
       124
       -
       

     

       125
       101
        
         /* Test some cross builds on 32 bit mingw-w64 */

     

       126
       126
       -
         crossMingw32 = let

     

       127
       127
       -
           crossSystem = {

     

       128
       128
       -
             config = "i686-pc-mingw32";

     

       129
       129
       -
             arch = "x86"; # Irrelevant

     

       130
       130
       -
             libc = "msvcrt"; # This distinguishes the mingw (non posix) toolchain

     

       131
       131
       -
             platform = {};

     

       132
       132
       -
           };

     

       133
       133
       -
         in mapTestOnCross crossSystem windowsCommon;

     

       134
       134
       -
       

     

       102
       102
       +
         crossMingw32 = mapTestOnCross lib.systems.examples.mingw32 windowsCommon;

     

       135
       103
        
       

     

       136
       104
        
         /* Test some cross builds on 64 bit mingw-w64 */

     

       137
       137
       -
         crossMingwW64 = let

     

       138
       138
       -
           crossSystem = {

     

       139
       139
       -
             # That's the triplet they use in the mingw-w64 docs.

     

       140
       140
       -
             config = "x86_64-pc-mingw32";

     

       141
       141
       -
             arch = "x86_64"; # Irrelevant

     

       142
       142
       -
             libc = "msvcrt"; # This distinguishes the mingw (non posix) toolchain

     

       143
       143
       -
             platform = {};

     

       144
       144
       -
           };

     

       145
       145
       -
         in mapTestOnCross crossSystem windowsCommon;

     

       146
       146
       -
       

     

       105
       105
       +
         crossMingwW64 = mapTestOnCross lib.systems.examples.mingwW64 windowsCommon;

     

       147
       106
        
       

     

       148
       107
        
         /* Linux on the fuloong */

     

       149
       149
       -
         fuloongminipc = let

     

       150
       150
       -
           crossSystem = {

     

       151
       151
       -
             config = "mips64el-unknown-linux-gnu";

     

       152
       152
       -
             bigEndian = false;

     

       153
       153
       -
             arch = "mips";

     

       154
       154
       -
             float = "hard";

     

       155
       155
       -
             withTLS = true;

     

       156
       156
       -
             libc = "glibc";

     

       157
       157
       -
             platform = lib.systems.platforms.fuloong2f_n32;

     

       158
       158
       -
             openssl.system = "linux-generic32";

     

       159
       159
       -
             gcc = {

     

       160
       160
       -
               arch = "loongson2f";

     

       161
       161
       -
               abi = "n32";

     

       162
       162
       -
             };

     

       163
       163
       -
           };

     

       164
       164
       -
         in mapTestOnCross crossSystem linuxCommon;

     

       165
       165
       -
       

     

       108
       108
       +
         fuloongminipc = mapTestOnCross lib.systems.examples.fuloongminipc linuxCommon;

     

       166
       109
        
       

     

       167
       110
        
         /* Linux on Raspberrypi */

     

       168
       168
       -
         rpi = let

     

       169
       169
       -
           crossSystem = {

     

       170
       170
       -
             config = "armv6l-unknown-linux-gnueabi";

     

       171
       171
       -
             bigEndian = false;

     

       172
       172
       -
             arch = "arm";

     

       173
       173
       -
             float = "hard";

     

       174
       174
       -
             fpu = "vfp";

     

       175
       175
       -
             withTLS = true;

     

       176
       176
       -
             libc = "glibc";

     

       177
       177
       -
             platform = lib.systems.platforms.raspberrypi;

     

       178
       178
       -
             openssl.system = "linux-generic32";

     

       179
       179
       -
             gcc = {

     

       180
       180
       -
               arch = "armv6";

     

       181
       181
       -
               fpu = "vfp";

     

       182
       182
       -
               float = "softfp";

     

       183
       183
       -
               abi = "aapcs-linux";

     

       184
       184
       -
             };

     

       185
       185
       -
           };

     

       186
       186
       -
         in mapTestOnCross crossSystem (linuxCommon // {

     

       111
       111
       +
         rpi = mapTestOnCross lib.systems.examples.raspberryPi (linuxCommon // {

     

       187
       112
        
           vim = nativePlatforms;

     

       188
       113
        
           unzip = nativePlatforms;

     

       189
       114
        
           ddrescue = nativePlatforms;