commit 0931f4e8618417869bb2cbfddfcb4baecfa20f56 · pyrox.dev/nixpkgs

+1 -3

lib/systems/default.nix

···

       121
       121
        
                     "uclibc"

     

       122
       122
        
                   else if final.isAndroid then

     

       123
       123
        
                     "bionic"

     

       124
       124
       -
                   else if final.isLLVMLibc then

     

       125
       125
       -
                     "llvm"

     

       126
       124
        
                   else if

     

       127
       125
        
                     final.isLinux # default

     

       128
       126
        
                   then

     
···

       248
       246
        
                 # don't support dynamic linking, but don't get the `staticMarker`.

     

       249
       247
        
                 # `pkgsStatic` sets `isStatic=true`, so `pkgsStatic.hostPlatform` always

     

       250
       248
        
                 # has the `staticMarker`.

     

       251
       251
       -
                 isStatic = final.isWasi || final.isRedox || final.isLLVMLibc;

     

       249
       249
       +
                 isStatic = final.isWasi || final.isRedox;

     

       252
       250
        
       

     

       253
       251
        
                 # Just a guess, based on `system`

     

       254
       252
        
                 inherit

-1

lib/systems/inspect.nix

···

       386
       386
        
               uclibceabi

     

       387
       387
        
               uclibceabihf

     

       388
       388
        
             ];

     

       389
       389
       -
           isLLVMLibc = [ { abi = abis.llvm; } ];

     

       390
       389
        
       

     

       391
       390
        
           isEfi = [

     

       392
       391
        
             {

-3

lib/systems/parse.nix

···

       740
       740
        
           };

     

       741
       741
        
           uclibc = { };

     

       742
       742
        
       

     

       743
       743
       -
           # LLVM libc

     

       744
       744
       -
           llvm = { };

     

       745
       745
       -
       

     

       746
       743
        
           unknown = { };

     

       747
       744
        
         };

     

       748
       745

-1

pkgs/top-level/release-attrpaths-superset.nix

···

       50
       50
        
       

     

       51
       51
        
           # cross packagesets

     

       52
       52
        
           pkgsLLVM = true;

     

       53
       53
       -
           pkgsLLVMLibc = true;

     

       54
       53
        
           pkgsMusl = true;

     

       55
       54
        
           pkgsStatic = true;

     

       56
       55
        
           pkgsCross = true;

-4

pkgs/top-level/release.nix

···

       382
       382
        
                 "x86_64-linux"

     

       383
       383
        
                 "aarch64-linux"

     

       384
       384
        
               ];

     

       385
       385
       -
               pkgsLLVMLibc.stdenv = [

     

       386
       386
       -
                 "x86_64-linux"

     

       387
       387
       -
                 "aarch64-linux"

     

       388
       388
       -
               ];

     

       389
       385
        
               pkgsArocc.stdenv = [

     

       390
       386
        
                 "x86_64-linux"

     

       391
       387
        
                 "aarch64-linux"

-24

pkgs/top-level/stage.nix

···

       115
       115
        
             }

     

       116
       116
        
           );

     

       117
       117
        
       

     

       118
       118
       -
         makeLLVMParsedPlatform =

     

       119
       119
       -
           parsed:

     

       120
       120
       -
           (

     

       121
       121
       -
             parsed

     

       122
       122
       -
             // {

     

       123
       123
       -
               abi = lib.systems.parse.abis.llvm;

     

       124
       124
       -
             }

     

       125
       125
       -
           );

     

       126
       126
       -
       

     

       127
       118
        
         stdenvAdapters =

     

       128
       119
        
           self: super:

     

       129
       120
        
           let

     
···

       243
       234
        
             crossSystem = stdenv.hostPlatform // {

     

       244
       235
        
               useLLVM = true;

     

       245
       236
        
               linker = "lld";

     

       246
       246
       -
             };

     

       247
       247
       -
           };

     

       248
       248
       -
       

     

       249
       249
       -
           pkgsLLVMLibc = nixpkgsFun {

     

       250
       250
       -
             overlays = [

     

       251
       251
       -
               (self': super': {

     

       252
       252
       -
                 pkgsLLVMLibc = super';

     

       253
       253
       -
               })

     

       254
       254
       -
             ] ++ overlays;

     

       255
       255
       -
             # Bootstrap a cross stdenv using LLVM libc.

     

       256
       256
       -
             # This is currently not possible when compiling natively,

     

       257
       257
       -
             # so we don't need to check hostPlatform != buildPlatform.

     

       258
       258
       -
             crossSystem = stdenv.hostPlatform // {

     

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

     

       260
       260
       -
               libc = "llvm";

     

       261
       237
        
             };

     

       262
       238
        
           };

     

       263
       239