commit 692a57e61d8e960a0163140eaec831158edb051b · pyrox.dev/nixpkgs

-128

pkgs/test/top-level/stage.nix

···

       1
       -
       # run like this:

     

       2
       -
       #  nix-build pkgs/test/top-level/stage.nix

     

       3
       -
       {

     

       4
       -
         localSystem ? {

     

       5
       -
           system = builtins.currentSystem;

     

       6
       -
         },

     

       7
       -
       }:

     

       8
       -
       

     

       9
       -
       with import ../../top-level { inherit localSystem; };

     

       10
       -
       

     

       11
       -
       let

     

       12
       -
         # To silence platform specific evaluation errors

     

       13
       -
         discardEvaluationErrors = e: (builtins.tryEval e).success -> e;

     

       14
       -
       

     

       15
       -
         # Basic test for idempotency of the package set, i.e:

     

       16
       -
         # Applying the same package set twice should work and

     

       17
       -
         # not change anything.

     

       18
       -
         isIdempotent = set: discardEvaluationErrors (pkgs.${set}.stdenv == pkgs.${set}.${set}.stdenv);

     

       19
       -
       

     

       20
       -
         # Some package sets should be noops in certain circumstances.

     

       21
       -
         # This is very similar to the idempotency test, but not going

     

       22
       -
         # via the super' overlay.

     

       23
       -
         isNoop =

     

       24
       -
           parent: child:

     

       25
       -
           discardEvaluationErrors (

     

       26
       -
             (lib.getAttrFromPath parent pkgs).stdenv == (lib.getAttrFromPath parent pkgs).${child}.stdenv

     

       27
       -
           );

     

       28
       -
       

     

       29
       -
         allMuslExamples = builtins.attrNames (

     

       30
       -
           lib.filterAttrs (_: system: lib.hasSuffix "-musl" system.config) lib.systems.examples

     

       31
       -
         );

     

       32
       -
       

     

       33
       -
         allLLVMExamples = builtins.attrNames (

     

       34
       -
           lib.filterAttrs (_: system: system.useLLVM or false) lib.systems.examples

     

       35
       -
         );

     

       36
       -
       

     

       37
       -
         # A package set should only change specific configuration, but needs

     

       38
       -
         # to keep all other configuration from previous layers in place.

     

       39
       -
         # Each package set has one or more key characteristics for which we

     

       40
       -
         # test here. Those should be kept, even when applying the "set" package

     

       41
       -
         # set.

     

       42
       -
         isComposable =

     

       43
       -
           set:

     

       44
       -
           (

     

       45
       -
             # Can't compose two different libcs...

     

       46
       -
             builtins.elem set [ "pkgsLLVMLibc" ]

     

       47
       -
             || discardEvaluationErrors (

     

       48
       -
               pkgsCross.mingwW64.${set}.stdenv.hostPlatform.config == "x86_64-w64-mingw32"

     

       49
       -
             )

     

       50
       -
           )

     

       51
       -
           && (

     

       52
       -
             # Can't compose two different libcs...

     

       53
       -
             builtins.elem set [ "pkgsLLVMLibc" ]

     

       54
       -
             || discardEvaluationErrors (pkgsCross.mingwW64.${set}.stdenv.hostPlatform.libc == "msvcrt")

     

       55
       -
           )

     

       56
       -
           && discardEvaluationErrors (pkgsCross.ppc64-musl.${set}.stdenv.hostPlatform.gcc.abi == "elfv2")

     

       57
       -
           && discardEvaluationErrors (

     

       58
       -
             builtins.elem "trivialautovarinit" pkgs.pkgsExtraHardening.${set}.stdenv.cc.defaultHardeningFlags

     

       59
       -
           )

     

       60
       -
           && discardEvaluationErrors (pkgs.pkgsLLVM.${set}.stdenv.hostPlatform.useLLVM)

     

       61
       -
           && (

     

       62
       -
             # Can't compose two different libcs...

     

       63
       -
             builtins.elem set [

     

       64
       -
               "pkgsMusl"

     

       65
       -
               "pkgsStatic"

     

       66
       -
             ]

     

       67
       -
             || discardEvaluationErrors (pkgs.pkgsLLVMLibc.${set}.stdenv.hostPlatform.isLLVMLibc)

     

       68
       -
           )

     

       69
       -
           && discardEvaluationErrors (pkgs.pkgsArocc.${set}.stdenv.hostPlatform.useArocc)

     

       70
       -
           && discardEvaluationErrors (pkgs.pkgsZig.${set}.stdenv.hostPlatform.useZig)

     

       71
       -
           && discardEvaluationErrors (pkgs.pkgsLinux.${set}.stdenv.buildPlatform.isLinux)

     

       72
       -
           && (

     

       73
       -
             # Can't compose two different libcs...

     

       74
       -
             builtins.elem set [ "pkgsLLVMLibc" ]

     

       75
       -
             || discardEvaluationErrors (pkgs.pkgsMusl.${set}.stdenv.hostPlatform.isMusl)

     

       76
       -
           )

     

       77
       -
           && discardEvaluationErrors (pkgs.pkgsStatic.${set}.stdenv.hostPlatform.isStatic)

     

       78
       -
           && discardEvaluationErrors (pkgs.pkgsi686Linux.${set}.stdenv.hostPlatform.isx86_32)

     

       79
       -
           && discardEvaluationErrors (pkgs.pkgsx86_64Darwin.${set}.stdenv.hostPlatform.isx86_64);

     

       80
       -
       in

     

       81
       -
       

     

       82
       -
       # Appends same defaultHardeningFlags again on each .pkgsExtraHardening - thus not idempotent.

     

       83
       -
       # assert isIdempotent "pkgsExtraHardening";

     

       84
       -
       # TODO: Remove the isDarwin condition, which currently results in infinite recursion.

     

       85
       -
       # Also see https://github.com/NixOS/nixpkgs/pull/330567#discussion_r1894653309

     

       86
       -
       assert (stdenv.hostPlatform.isDarwin || isIdempotent "pkgsLLVM");

     

       87
       -
       # TODO: This currently results in infinite recursion, even on Linux

     

       88
       -
       # assert isIdempotent "pkgsLLVMLibc";

     

       89
       -
       assert isIdempotent "pkgsArocc";

     

       90
       -
       assert isIdempotent "pkgsZig";

     

       91
       -
       assert isIdempotent "pkgsLinux";

     

       92
       -
       assert isIdempotent "pkgsMusl";

     

       93
       -
       assert isIdempotent "pkgsStatic";

     

       94
       -
       assert isIdempotent "pkgsi686Linux";

     

       95
       -
       assert isIdempotent "pkgsx86_64Darwin";

     

       96
       -
       

     

       97
       -
       assert isNoop [ "pkgsStatic" ] "pkgsMusl";

     

       98
       -
       assert lib.all (sys: isNoop [ "pkgsCross" sys ] "pkgsMusl") allMuslExamples;

     

       99
       -
       assert lib.all (sys: isNoop [ "pkgsCross" sys ] "pkgsLLVM") allLLVMExamples;

     

       100
       -
       

     

       101
       -
       assert isComposable "pkgsExtraHardening";

     

       102
       -
       assert isComposable "pkgsLLVM";

     

       103
       -
       # TODO: Results in infinite recursion

     

       104
       -
       # assert isComposable "pkgsLLVMLibc";

     

       105
       -
       assert isComposable "pkgsArocc";

     

       106
       -
       # TODO: unexpected argument 'bintools' - uncomment once https://github.com/NixOS/nixpkgs/pull/331011 is done

     

       107
       -
       # assert isComposable "pkgsZig";

     

       108
       -
       assert isComposable "pkgsMusl";

     

       109
       -
       assert isComposable "pkgsStatic";

     

       110
       -
       assert isComposable "pkgsi686Linux";

     

       111
       -
       

     

       112
       -
       # Special cases regarding buildPlatform vs hostPlatform

     

       113
       -
       assert discardEvaluationErrors (pkgsCross.gnu64.pkgsMusl.stdenv.hostPlatform.isMusl);

     

       114
       -
       assert discardEvaluationErrors (pkgsCross.gnu64.pkgsi686Linux.stdenv.hostPlatform.isx86_32);

     

       115
       -
       assert discardEvaluationErrors (pkgsCross.mingwW64.pkgsLinux.stdenv.hostPlatform.isLinux);

     

       116
       -
       assert discardEvaluationErrors (

     

       117
       -
         pkgsCross.aarch64-darwin.pkgsx86_64Darwin.stdenv.hostPlatform.isx86_64

     

       118
       -
       );

     

       119
       -
       

     

       120
       -
       # pkgsCross should keep upper cross settings

     

       121
       -
       assert discardEvaluationErrors (

     

       122
       -
         with pkgsStatic.pkgsCross.gnu64.stdenv.hostPlatform; isGnu && isStatic

     

       123
       -
       );

     

       124
       -
       assert discardEvaluationErrors (

     

       125
       -
         with pkgsLLVM.pkgsCross.musl64.stdenv.hostPlatform; isMusl && useLLVM

     

       126
       -
       );

     

       127
       -
       

     

       128
       -
       emptyFile

+11 -7

pkgs/top-level/default.nix

···

       122
        
         config = lib.showWarnings configEval.config.warnings configEval.config;

     

       123
        
       

     

       124
        
         # A few packages make a new package set to draw their dependencies from.

     

       125
       -
         # Rather than give `all-packages.nix` all the arguments to this function,

     

       126
       -
         # even ones that don't concern it, we give it this function to "re-call"

     

       127
       -
         # nixpkgs, inheriting whatever arguments it doesn't explicitly provide. This

     

       128
       -
         # way, `all-packages.nix` doesn't know more than it needs to.

     

       0
        
       
     

       129
        
         #

     

       130
        
         # It's OK that `args` doesn't include default arguments from this file:

     

       131
        
         # they'll be deterministically inferred. In fact we must *not* include them,

     

       132
        
         # because it's important that if some parameter which affects the default is

     

       133
        
         # substituted with a different argument, the default is re-inferred.

     

       134
        
         #

     

       135
       -
         # To put this in concrete terms, we want the provided non-native `localSystem`

     

       136
       -
         # and `crossSystem` arguments to affect the stdenv chosen.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       137
        
         #

     

       138
        
         # NB!!! This thing gets its `config` argument from `args`, i.e. it's actually

     

       139
        
         # `config0`. It is important to keep it to `config0` format (as opposed to the

     
···

       142
        
         # via `evalModules` is not idempotent. In other words, if you add `config` to

     

       143
        
         # `newArgs`, expect strange very hard to debug errors! (Yes, I'm speaking from

     

       144
        
         # experience here.)

     

       145
       -
         nixpkgsFun = f0: import ./. (args // f0 args);

     

       146
        
       

     

       147
        
         # Partially apply some arguments for building bootstraping stage pkgs

     

       148
        
         # sets. Only apply arguments which no stdenv would want to override.

···

       122
        
         config = lib.showWarnings configEval.config.warnings configEval.config;

     

       123
        
       

     

       124
        
         # A few packages make a new package set to draw their dependencies from.

     

       125
       +
         # (Currently to get a cross tool chain, or forced-i686 package.) Rather than

     

       126
       +
         # give `all-packages.nix` all the arguments to this function, even ones that

     

       127
       +
         # don't concern it, we give it this function to "re-call" nixpkgs, inheriting

     

       128
       +
         # whatever arguments it doesn't explicitly provide. This way,

     

       129
       +
         # `all-packages.nix` doesn't know more than it needs too.

     

       130
        
         #

     

       131
        
         # It's OK that `args` doesn't include default arguments from this file:

     

       132
        
         # they'll be deterministically inferred. In fact we must *not* include them,

     

       133
        
         # because it's important that if some parameter which affects the default is

     

       134
        
         # substituted with a different argument, the default is re-inferred.

     

       135
        
         #

     

       136
       +
         # To put this in concrete terms, this function is basically just used today to

     

       137
       +
         # use package for a different platform for the current platform (namely cross

     

       138
       +
         # compiling toolchains and 32-bit packages on x86_64). In both those cases we

     

       139
       +
         # want the provided non-native `localSystem` argument to affect the stdenv

     

       140
       +
         # chosen.

     

       141
        
         #

     

       142
        
         # NB!!! This thing gets its `config` argument from `args`, i.e. it's actually

     

       143
        
         # `config0`. It is important to keep it to `config0` format (as opposed to the

     
···

       146
        
         # via `evalModules` is not idempotent. In other words, if you add `config` to

     

       147
        
         # `newArgs`, expect strange very hard to debug errors! (Yes, I'm speaking from

     

       148
        
         # experience here.)

     

       149
       +
         nixpkgsFun = newArgs: import ./. (args // newArgs);

     

       150
        
       

     

       151
        
         # Partially apply some arguments for building bootstraping stage pkgs

     

       152
        
         # sets. Only apply arguments which no stdenv would want to override.

+123 -83

pkgs/top-level/stage.nix

···

       180
        
             ((config.packageOverrides or (super: {})) super);

     

       181
        
       

     

       182
        
         # Convenience attributes for instantitating package sets. Each of

     

       183
       -
         # these will instantiate a new version of allPackages.

     

       184
       -
         otherPackageSets = let

     

       185
       -
           mkPkgs = name: fn: nixpkgsFun (prevArgs: let nixpkgsArgs = fn prevArgs; in nixpkgsArgs // {

     

       186
       -
             overlays = [

     

       187
       -
               (self': super': {

     

       188
       -
                 "${name}" = super';

     

       189
       -
               })

     

       190
       -
             ] ++ nixpkgsArgs.overlays or [] ++ prevArgs.overlays or [];

     

       191
       -
           });

     

       192
       -
           # This is always cross.

     

       193
       -
           mkCrossPkgs = name: crossAttrs: mkPkgs name (prevArgs: {

     

       194
       -
             crossSystem =

     

       195
       -
               (lib.systems.systemToAttrs (lib.defaultTo prevArgs.localSystem prevArgs.crossSystem or null)) // crossAttrs;

     

       196
       -
           });

     

       197
       -
           # This is only cross when we are already cross, otherwise local.

     

       198
       -
           # For the case of "native cross", i.e. pkgsCross.gnu64 on a x86_64-linux system, we need to adjust **both**

     

       199
       -
           # localSystem **and** crossSystem, otherwise they're out of sync.

     

       200
       -
           mkHybridPkgs = name: hybridAttrs: mkPkgs name (prevArgs: let

     

       201
       -
               newSystem = (lib.systems.systemToAttrs (lib.defaultTo prevArgs.localSystem prevArgs.crossSystem or null)) // hybridAttrs;

     

       202
       -
             in { crossSystem = newSystem; }

     

       203
       -
             // lib.optionalAttrs (stdenv.hostPlatform == stdenv.buildPlatform) { localSystem = newSystem; }

     

       204
       -
           );

     

       205
       -
         in self: super: {

     

       206
        
           # This maps each entry in lib.systems.examples to its own package

     

       207
        
           # set. Each of these will contain all packages cross compiled for

     

       208
        
           # that target system. For instance, pkgsCross.raspberryPi.hello,

     

       209
        
           # will refer to the "hello" package built for the ARM6-based

     

       210
        
           # Raspberry Pi.

     

       211
        
           pkgsCross = lib.mapAttrs (n: crossSystem:

     

       212
       -
                                     nixpkgsFun (prevArgs: { crossSystem = (lib.systems.systemToAttrs (lib.defaultTo { } prevArgs.crossSystem or null)) // crossSystem; }))

     

       213
        
                                     lib.systems.examples;

     

       214
        
       

     

       215
       -
           # Bootstrap a cross stdenv using the LLVM toolchain.

     

       216
       -
           # This is currently not possible when compiling natively.

     

       217
       -
           pkgsLLVM = mkCrossPkgs "pkgsLLVM" {

     

       218
       -
             useLLVM = true;

     

       219
       -
             linker = "lld";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       220
        
           };

     

       221
        
       

     

       222
       -
           # Bootstrap a cross stdenv using LLVM libc.

     

       223
       -
           # This is currently not possible when compiling natively.

     

       224
       -
           pkgsLLVMLibc = mkCrossPkgs "pkgsLLVMLibc" {

     

       225
       -
             config = lib.systems.parse.tripleFromSystem (makeLLVMParsedPlatform stdenv.hostPlatform.parsed);

     

       226
       -
             libc = "llvm";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       227
        
           };

     

       228
        
       

     

       229
       -
           # Bootstrap a cross stdenv using the Aro C compiler.

     

       230
       -
           # This is currently not possible when compiling natively.

     

       231
       -
           pkgsArocc = mkCrossPkgs "pkgsArocc" {

     

       232
       -
             useArocc = true;

     

       233
       -
             linker = "lld";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       234
        
           };

     

       235
        
       

     

       236
       -
           # Bootstrap a cross stdenv using the Zig toolchain.

     

       237
       -
           # This is currently not possible when compiling natively.

     

       238
       -
           pkgsZig = mkCrossPkgs "pkgsZig" {

     

       239
       -
             useZig = true;

     

       240
       -
             linker = "lld";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       241
        
           };

     

       242
        
       

     

       243
        
           # All packages built with the Musl libc. This will override the

     

       244
        
           # default GNU libc on Linux systems. Non-Linux systems are not

     

       245
        
           # supported. 32-bit is also not supported.

     

       246
       -
           pkgsMusl = if stdenv.hostPlatform.isLinux && stdenv.buildPlatform.is64bit then mkHybridPkgs "pkgsMusl" {

     

       247
       -
             config = lib.systems.parse.tripleFromSystem (makeMuslParsedPlatform stdenv.hostPlatform.parsed);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       248
        
           } else throw "Musl libc only supports 64-bit Linux systems.";

     

       249
        
       

     

       250
        
           # All packages built for i686 Linux.

     

       251
        
           # Used by wine, firefox with debugging version of Flash, ...

     

       252
       -
           pkgsi686Linux = if stdenv.hostPlatform.isLinux && stdenv.hostPlatform.isx86 then mkHybridPkgs "pkgsi686Linux" {

     

       253
       -
             config = lib.systems.parse.tripleFromSystem (stdenv.hostPlatform.parsed // {

     

       254
       -
               cpu = lib.systems.parse.cpuTypes.i686;

     

       255
       -
             });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       256
        
           } else throw "i686 Linux package set can only be used with the x86 family.";

     

       257
        
       

     

       258
        
           # x86_64-darwin packages for aarch64-darwin users to use with Rosetta for incompatible packages

     

       259
       -
           pkgsx86_64Darwin = if stdenv.hostPlatform.isDarwin then mkHybridPkgs "pkgsx86_64Darwin" {

     

       260
       -
             config = lib.systems.parse.tripleFromSystem (stdenv.hostPlatform.parsed // {

     

       261
       -
               cpu = lib.systems.parse.cpuTypes.x86_64;

     

       262
       -
             });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       263
        
           } else throw "x86_64 Darwin package set can only be used on Darwin systems.";

     

       264
        
       

     

       265
        
           # If already linux: the same package set unaltered

     

       266
       -
           # Otherwise, return a linux package set for the current cpu architecture string.

     

       267
        
           # (ABI and other details will be set to the default for the cpu/os pair)

     

       268
        
           pkgsLinux =

     

       269
        
             if stdenv.hostPlatform.isLinux

     

       270
        
             then self

     

       271
       -
             else mkHybridPkgs "pkgsLinux" {

     

       272
       -
               config = lib.systems.parse.tripleFromSystem (lib.systems.elaborate "${stdenv.hostPlatform.parsed.cpu.name}-linux").parsed;

     

       273
        
             };

     

       274
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       275
        
           # Fully static packages.

     

       276
        
           # Currently uses Musl on Linux (couldn’t get static glibc to work).

     

       277
       -
           pkgsStatic = mkCrossPkgs "pkgsStatic" ({

     

       278
       -
             isStatic = true;

     

       279
       -
           } // lib.optionalAttrs stdenv.hostPlatform.isLinux {

     

       280
       -
             config = lib.systems.parse.tripleFromSystem (makeMuslParsedPlatform stdenv.hostPlatform.parsed);

     

       281
       -
           } // lib.optionalAttrs (stdenv.hostPlatform.system == "powerpc64-linux") {

     

       282
       -
             gcc = { abi = "elfv2"; } // stdenv.hostPlatform.gcc or {};

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       283
        
           });

     

       284
        
       

     

       285
       -
           pkgsExtraHardening = mkPkgs "pkgsExtraHardening" (_: {

     

       286
        
             overlays = [

     

       287
        
               (self': super': {

     

       0
        
       
     

       288
        
                 stdenv = super'.withDefaultHardeningFlags (

     

       289
        
                   super'.stdenv.cc.defaultHardeningFlags ++ [

     

       290
        
                     "shadowstack"

     
···

       303
        
                 pcre-cpp = super'.pcre-cpp.override { enableJit = false; };

     

       304
        
                 pcre16 = super'.pcre16.override { enableJit = false; };

     

       305
        
               })

     

       306
       -
             ];

     

       307
       -
           });

     

       308
       -
       

     

       309
       -
           # Extend the package set with zero or more overlays. This preserves

     

       310
       -
           # preexisting overlays. Prefer to initialize with the right overlays

     

       311
       -
           # in one go when calling Nixpkgs, for performance and simplicity.

     

       312
       -
           appendOverlays = extraOverlays:

     

       313
       -
             if extraOverlays == []

     

       314
       -
             then self

     

       315
       -
             else nixpkgsFun (prevArgs: { overlays = prevArgs.overlays ++ extraOverlays; });

     

       316
       -
       

     

       317
       -
           # NOTE: each call to extend causes a full nixpkgs rebuild, adding ~130MB

     

       318
       -
           #       of allocations. DO NOT USE THIS IN NIXPKGS.

     

       319
       -
           #

     

       320
       -
           # Extend the package set with a single overlay. This preserves

     

       321
       -
           # preexisting overlays. Prefer to initialize with the right overlays

     

       322
       -
           # in one go when calling Nixpkgs, for performance and simplicity.

     

       323
       -
           # Prefer appendOverlays if used repeatedly.

     

       324
       -
           extend = f: self.appendOverlays [f];

     

       325
        
         };

     

       326
        
       

     

       327
        
         # The complete chain of package set builders, applied from top to bottom.

···

       180
        
             ((config.packageOverrides or (super: {})) super);

     

       181
        
       

     

       182
        
         # Convenience attributes for instantitating package sets. Each of

     

       183
       +
         # these will instantiate a new version of allPackages. Currently the

     

       184
       +
         # following package sets are provided:

     

       185
       +
         #

     

       186
       +
         # - pkgsCross.<system> where system is a member of lib.systems.examples

     

       187
       +
         # - pkgsMusl

     

       188
       +
         # - pkgsi686Linux

     

       189
       +
         otherPackageSets = self: super: {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       190
        
           # This maps each entry in lib.systems.examples to its own package

     

       191
        
           # set. Each of these will contain all packages cross compiled for

     

       192
        
           # that target system. For instance, pkgsCross.raspberryPi.hello,

     

       193
        
           # will refer to the "hello" package built for the ARM6-based

     

       194
        
           # Raspberry Pi.

     

       195
        
           pkgsCross = lib.mapAttrs (n: crossSystem:

     

       196
       +
                                     nixpkgsFun { inherit crossSystem; })

     

       197
        
                                     lib.systems.examples;

     

       198
        
       

     

       199
       +
           pkgsLLVM = nixpkgsFun {

     

       200
       +
             overlays = [

     

       201
       +
               (self': super': {

     

       202
       +
                 pkgsLLVM = super';

     

       203
       +
               })

     

       204
       +
             ] ++ overlays;

     

       205
       +
             # Bootstrap a cross stdenv using the LLVM toolchain.

     

       206
       +
             # This is currently not possible when compiling natively,

     

       207
       +
             # so we don't need to check hostPlatform != buildPlatform.

     

       208
       +
             crossSystem = stdenv.hostPlatform // {

     

       209
       +
               useLLVM = true;

     

       210
       +
               linker = "lld";

     

       211
       +
             };

     

       212
        
           };

     

       213
        
       

     

       214
       +
           pkgsLLVMLibc = nixpkgsFun {

     

       215
       +
             overlays = [ (self': super': {

     

       216
       +
               pkgsLLVMLibc = super';

     

       217
       +
             })] ++ overlays;

     

       218
       +
             # Bootstrap a cross stdenv using LLVM libc.

     

       219
       +
             # This is currently not possible when compiling natively,

     

       220
       +
             # so we don't need to check hostPlatform != buildPlatform.

     

       221
       +
             crossSystem = stdenv.hostPlatform // {

     

       222
       +
               config = lib.systems.parse.tripleFromSystem (makeLLVMParsedPlatform stdenv.hostPlatform.parsed);

     

       223
       +
               libc = "llvm";

     

       224
       +
             };

     

       225
        
           };

     

       226
        
       

     

       227
       +
           pkgsArocc = nixpkgsFun {

     

       228
       +
             overlays = [

     

       229
       +
               (self': super': {

     

       230
       +
                 pkgsArocc = super';

     

       231
       +
               })

     

       232
       +
             ] ++ overlays;

     

       233
       +
             # Bootstrap a cross stdenv using the Aro C compiler.

     

       234
       +
             # This is currently not possible when compiling natively,

     

       235
       +
             # so we don't need to check hostPlatform != buildPlatform.

     

       236
       +
             crossSystem = stdenv.hostPlatform // {

     

       237
       +
               useArocc = true;

     

       238
       +
               linker = "lld";

     

       239
       +
             };

     

       240
        
           };

     

       241
        
       

     

       242
       +
           pkgsZig = nixpkgsFun {

     

       243
       +
             overlays = [

     

       244
       +
               (self': super': {

     

       245
       +
                 pkgsZig = super';

     

       246
       +
               })

     

       247
       +
             ] ++ overlays;

     

       248
       +
             # Bootstrap a cross stdenv using the Zig toolchain.

     

       249
       +
             # This is currently not possible when compiling natively,

     

       250
       +
             # so we don't need to check hostPlatform != buildPlatform.

     

       251
       +
             crossSystem = stdenv.hostPlatform // {

     

       252
       +
               useZig = true;

     

       253
       +
               linker = "lld";

     

       254
       +
             };

     

       255
        
           };

     

       256
        
       

     

       257
        
           # All packages built with the Musl libc. This will override the

     

       258
        
           # default GNU libc on Linux systems. Non-Linux systems are not

     

       259
        
           # supported. 32-bit is also not supported.

     

       260
       +
           pkgsMusl = if stdenv.hostPlatform.isLinux && stdenv.buildPlatform.is64bit then nixpkgsFun {

     

       261
       +
             overlays = [ (self': super': {

     

       262
       +
               pkgsMusl = super';

     

       263
       +
             })] ++ overlays;

     

       264
       +
             ${if stdenv.hostPlatform == stdenv.buildPlatform

     

       265
       +
               then "localSystem" else "crossSystem"} = {

     

       266
       +
               config = lib.systems.parse.tripleFromSystem (makeMuslParsedPlatform stdenv.hostPlatform.parsed);

     

       267
       +
             };

     

       268
        
           } else throw "Musl libc only supports 64-bit Linux systems.";

     

       269
        
       

     

       270
        
           # All packages built for i686 Linux.

     

       271
        
           # Used by wine, firefox with debugging version of Flash, ...

     

       272
       +
           pkgsi686Linux = if stdenv.hostPlatform.isLinux && stdenv.hostPlatform.isx86 then nixpkgsFun {

     

       273
       +
             overlays = [ (self': super': {

     

       274
       +
               pkgsi686Linux = super';

     

       275
       +
             })] ++ overlays;

     

       276
       +
             ${if stdenv.hostPlatform == stdenv.buildPlatform

     

       277
       +
               then "localSystem" else "crossSystem"} = {

     

       278
       +
               config = lib.systems.parse.tripleFromSystem (stdenv.hostPlatform.parsed // {

     

       279
       +
                 cpu = lib.systems.parse.cpuTypes.i686;

     

       280
       +
               });

     

       281
       +
             };

     

       282
        
           } else throw "i686 Linux package set can only be used with the x86 family.";

     

       283
        
       

     

       284
        
           # x86_64-darwin packages for aarch64-darwin users to use with Rosetta for incompatible packages

     

       285
       +
           pkgsx86_64Darwin = if stdenv.hostPlatform.isDarwin then nixpkgsFun {

     

       286
       +
             overlays = [ (self': super': {

     

       287
       +
               pkgsx86_64Darwin = super';

     

       288
       +
             })] ++ overlays;

     

       289
       +
             localSystem = {

     

       290
       +
               config = lib.systems.parse.tripleFromSystem (stdenv.hostPlatform.parsed // {

     

       291
       +
                 cpu = lib.systems.parse.cpuTypes.x86_64;

     

       292
       +
               });

     

       293
       +
             };

     

       294
        
           } else throw "x86_64 Darwin package set can only be used on Darwin systems.";

     

       295
        
       

     

       296
        
           # If already linux: the same package set unaltered

     

       297
       +
           # Otherwise, return a natively built linux package set for the current cpu architecture string.

     

       298
        
           # (ABI and other details will be set to the default for the cpu/os pair)

     

       299
        
           pkgsLinux =

     

       300
        
             if stdenv.hostPlatform.isLinux

     

       301
        
             then self

     

       302
       +
             else nixpkgsFun {

     

       303
       +
               localSystem = lib.systems.elaborate "${stdenv.hostPlatform.parsed.cpu.name}-linux";

     

       304
        
             };

     

       305
        
       

     

       306
       +
           # Extend the package set with zero or more overlays. This preserves

     

       307
       +
           # preexisting overlays. Prefer to initialize with the right overlays

     

       308
       +
           # in one go when calling Nixpkgs, for performance and simplicity.

     

       309
       +
           appendOverlays = extraOverlays:

     

       310
       +
             if extraOverlays == []

     

       311
       +
             then self

     

       312
       +
             else nixpkgsFun { overlays = args.overlays ++ extraOverlays; };

     

       313
       +
       

     

       314
       +
           # NOTE: each call to extend causes a full nixpkgs rebuild, adding ~130MB

     

       315
       +
           #       of allocations. DO NOT USE THIS IN NIXPKGS.

     

       316
       +
           #

     

       317
       +
           # Extend the package set with a single overlay. This preserves

     

       318
       +
           # preexisting overlays. Prefer to initialize with the right overlays

     

       319
       +
           # in one go when calling Nixpkgs, for performance and simplicity.

     

       320
       +
           # Prefer appendOverlays if used repeatedly.

     

       321
       +
           extend = f: self.appendOverlays [f];

     

       322
       +
       

     

       323
        
           # Fully static packages.

     

       324
        
           # Currently uses Musl on Linux (couldn’t get static glibc to work).

     

       325
       +
           pkgsStatic = nixpkgsFun ({

     

       326
       +
             overlays = [ (self': super': {

     

       327
       +
               pkgsStatic = super';

     

       328
       +
             })] ++ overlays;

     

       329
       +
             crossSystem = {

     

       330
       +
               isStatic = true;

     

       331
       +
               config = lib.systems.parse.tripleFromSystem (

     

       332
       +
                 if stdenv.hostPlatform.isLinux

     

       333
       +
                 then makeMuslParsedPlatform stdenv.hostPlatform.parsed

     

       334
       +
                 else stdenv.hostPlatform.parsed

     

       335
       +
               );

     

       336
       +
               gcc = lib.optionalAttrs (stdenv.hostPlatform.system == "powerpc64-linux") { abi = "elfv2"; } //

     

       337
       +
                 stdenv.hostPlatform.gcc or {};

     

       338
       +
             };

     

       339
        
           });

     

       340
        
       

     

       341
       +
           pkgsExtraHardening = nixpkgsFun {

     

       342
        
             overlays = [

     

       343
        
               (self': super': {

     

       344
       +
                 pkgsExtraHardening = super';

     

       345
        
                 stdenv = super'.withDefaultHardeningFlags (

     

       346
        
                   super'.stdenv.cc.defaultHardeningFlags ++ [

     

       347
        
                     "shadowstack"

     
···

       360
        
                 pcre-cpp = super'.pcre-cpp.override { enableJit = false; };

     

       361
        
                 pcre16 = super'.pcre16.override { enableJit = false; };

     

       362
        
               })

     

       363
       +
             ] ++ overlays;

     

       364
       +
           };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       365
        
         };

     

       366
        
       

     

       367
        
         # The complete chain of package set builders, applied from top to bottom.