commit b1434f14da608b9e19f56fe9cad6ee0b0d81c1cf · pyrox.dev/nixpkgs

+6 -7

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

···

       27
       27
        
       , cloog ? null # unused; just for compat with gcc4, as we override the parameter on some places

     

       28
       28
        
       , buildPackages

     

       29
       29
        
       , libxcrypt

     

       30
       30
       +
       , callPackage

     

       30
       31
        
       }:

     

       31
       32
        
       

     

       32
       33
        
       # Make sure we get GNU sed.

     
···

       143
       144
        
       

     

       144
       145
        
       in

     

       145
       146
        
       

     

       146
       146
       -
       stdenv.mkDerivation ({

     

       147
       147
       +
       lib.pipe (stdenv.mkDerivation ({

     

       147
       148
        
         pname = "${crossNameAddon}${name}";

     

       148
       149
        
         inherit version;

     

       149
       150
        
       

     
···

       291
       292
        
       

     

       292
       293
        
       }

     

       293
       294
        
       

     

       294
       294
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       295
       295
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       296
       296
       -
         installTargets = "install-gcc install-target-libgcc";

     

       297
       297
       -
       }

     

       298
       298
       -
       

     

       299
       295
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       300
       300
       -
       )

     

       296
       296
       +
       ))

     

       297
       297
       +
       [

     

       298
       298
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       299
       299
       +
       ]

+1 -6

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

···

       304
       304
        
         };

     

       305
       305
        
       }

     

       306
       306
        
       

     

       307
       307
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       308
       308
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       309
       309
       -
         installTargets = "install-gcc install-target-libgcc";

     

       310
       310
       -
       }

     

       311
       311
       -
       

     

       312
       307
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       313
       308
        
       ))

     

       314
       309
        
       [

     

       315
       315
       -
         (callPackage ../common/libgcc.nix   { inherit langC langCC langJit; })

     

       310
       310
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       316
       311
        
         (callPackage ../common/checksum.nix { inherit langC langCC; })

     

       317
       312
        
       ]

+1 -6

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

···

       350
       350
        
         };

     

       351
       351
        
       }

     

       352
       352
        
       

     

       353
       353
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       354
       354
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       355
       355
       -
         installTargets = "install-gcc install-target-libgcc";

     

       356
       356
       -
       }

     

       357
       357
       -
       

     

       358
       353
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       359
       354
        
       ))

     

       360
       355
        
       [

     

       361
       361
       -
         (callPackage ../common/libgcc.nix   { inherit langC langCC langJit; })

     

       356
       356
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       362
       357
        
         (callPackage ../common/checksum.nix { inherit langC langCC; })

     

       363
       358
        
       ]

     

       364
       359

+1 -6

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

···

       344
       344
        
         };

     

       345
       345
        
       }

     

       346
       346
        
       

     

       347
       347
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       348
       348
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       349
       349
       -
         installTargets = "install-gcc install-target-libgcc";

     

       350
       350
       -
       }

     

       351
       351
       -
       

     

       352
       347
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       353
       348
        
       ))

     

       354
       349
        
       [

     

       355
       355
       -
         (callPackage ../common/libgcc.nix   { inherit langC langCC langJit; })

     

       350
       350
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       356
       351
        
         (callPackage ../common/checksum.nix { inherit langC langCC; })

     

       357
       352
        
       ]

     

       358
       353

+6 -7

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

···

       29
       29
        
       , crossStageStatic ? false

     

       30
       30
        
       , gnused ? null

     

       31
       31
        
       , buildPackages

     

       32
       32
       +
       , callPackage

     

       32
       33
        
       }:

     

       33
       34
        
       

     

       34
       35
        
       assert langJava     -> zip != null && unzip != null

     
···

       192
       193
        
       # We need all these X libraries when building AWT with GTK.

     

       193
       194
        
       assert x11Support -> (filter (x: x == null) ([ gtk2 libart_lgpl ] ++ xlibs)) == [];

     

       194
       195
        
       

     

       195
       195
       -
       stdenv.mkDerivation ({

     

       196
       196
       +
       lib.pipe (stdenv.mkDerivation ({

     

       196
       197
        
         pname = "${crossNameAddon}${name}";

     

       197
       198
        
         inherit version;

     

       198
       199
        
       

     
···

       319
       320
        
         };

     

       320
       321
        
       }

     

       321
       322
        
       

     

       322
       322
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       323
       323
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       324
       324
       -
         installTargets = "install-gcc install-target-libgcc";

     

       325
       325
       -
       }

     

       326
       326
       -
       

     

       327
       323
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       328
       328
       -
       )

     

       324
       324
       +
       ))

     

       325
       325
       +
       [

     

       326
       326
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       327
       327
       +
       ]

+6 -7

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

···

       29
       29
        
       , crossStageStatic ? false

     

       30
       30
        
       , gnused ? null

     

       31
       31
        
       , buildPackages

     

       32
       32
       +
       , callPackage

     

       32
       33
        
       }:

     

       33
       34
        
       

     

       34
       35
        
       assert langJava     -> zip != null && unzip != null

     
···

       209
       210
        
       # We need all these X libraries when building AWT with GTK.

     

       210
       211
        
       assert x11Support -> (filter (x: x == null) ([ gtk2 libart_lgpl ] ++ xlibs)) == [];

     

       211
       212
        
       

     

       212
       212
       -
       stdenv.mkDerivation ({

     

       213
       213
       +
       lib.pipe (stdenv.mkDerivation ({

     

       213
       214
        
         pname = "${crossNameAddon}${name}";

     

       214
       215
        
         inherit version;

     

       215
       216
        
       

     
···

       340
       341
        
         };

     

       341
       342
        
       }

     

       342
       343
        
       

     

       343
       343
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       344
       344
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       345
       345
       -
         installTargets = "install-gcc install-target-libgcc";

     

       346
       346
       -
       }

     

       347
       347
       -
       

     

       348
       344
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       349
       345
        
       

     

       350
       346
        
       // optionalAttrs (langJava) {

     
···

       352
       348
        
              target="$(echo "$out/libexec/gcc"/*/*/ecj*)"

     

       353
       349
        
              patchelf --set-rpath "$(patchelf --print-rpath "$target"):$out/lib" "$target"

     

       354
       350
        
            '';}

     

       355
       355
       -
       )

     

       351
       351
       +
       ))

     

       352
       352
       +
       [

     

       353
       353
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       354
       354
       +
       ]

+6 -7

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

···

       33
       33
        
       , gnused ? null

     

       34
       34
        
       , cloog ? null # unused; just for compat with gcc4, as we override the parameter on some places

     

       35
       35
        
       , buildPackages

     

       36
       36
       +
       , callPackage

     

       36
       37
        
       }:

     

       37
       38
        
       

     

       38
       39
        
       assert langJava     -> zip != null && unzip != null

     
···

       198
       199
        
       # We need all these X libraries when building AWT with GTK.

     

       199
       200
        
       assert x11Support -> (filter (x: x == null) ([ gtk2 libart_lgpl ] ++ xlibs)) == [];

     

       200
       201
        
       

     

       201
       201
       -
       stdenv.mkDerivation ({

     

       202
       202
       +
       lib.pipe (stdenv.mkDerivation ({

     

       202
       203
        
         pname = "${crossNameAddon}${name}";

     

       203
       204
        
         inherit version;

     

       204
       205
        
       

     
···

       358
       359
        
         };

     

       359
       360
        
       }

     

       360
       361
        
       

     

       361
       361
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       362
       362
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       363
       363
       -
         installTargets = "install-gcc install-target-libgcc";

     

       364
       364
       -
       }

     

       365
       365
       -
       

     

       366
       362
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       367
       363
        
       

     

       368
       364
        
       // optionalAttrs (langJava && !stdenv.hostPlatform.isDarwin) {

     
···

       370
       366
        
              target="$(echo "$out/libexec/gcc"/*/*/ecj*)"

     

       371
       367
        
              patchelf --set-rpath "$(patchelf --print-rpath "$target"):$out/lib" "$target"

     

       372
       368
        
            '';}

     

       373
       373
       -
       )

     

       369
       369
       +
       ))

     

       370
       370
       +
       [

     

       371
       371
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       372
       372
       +
       ]

+6 -7

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

···

       23
       23
        
       , gnused ? null

     

       24
       24
        
       , cloog ? null # unused; just for compat with gcc4, as we override the parameter on some places

     

       25
       25
        
       , buildPackages

     

       26
       26
       +
       , callPackage

     

       26
       27
        
       }:

     

       27
       28
        
       

     

       28
       29
        
       # Make sure we get GNU sed.

     
···

       148
       149
        
       

     

       149
       150
        
       in

     

       150
       151
        
       

     

       151
       151
       -
       stdenv.mkDerivation ({

     

       152
       152
       +
       lib.pipe (stdenv.mkDerivation ({

     

       152
       153
        
         pname = "${crossNameAddon}${name}";

     

       153
       154
        
         inherit version;

     

       154
       155
        
       

     
···

       298
       299
        
         };

     

       299
       300
        
       }

     

       300
       301
        
       

     

       301
       301
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       302
       302
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       303
       303
       -
         installTargets = "install-gcc install-target-libgcc";

     

       304
       304
       -
       }

     

       305
       305
       -
       

     

       306
       302
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       307
       307
       -
       )

     

       303
       303
       +
       ))

     

       304
       304
       +
       [

     

       305
       305
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       306
       306
       +
       ]

+6 -7

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

···

       23
       23
        
       , gnused ? null

     

       24
       24
        
       , cloog ? null # unused; just for compat with gcc4, as we override the parameter on some places

     

       25
       25
        
       , buildPackages

     

       26
       26
       +
       , callPackage

     

       26
       27
        
       }:

     

       27
       28
        
       

     

       28
       29
        
       # Make sure we get GNU sed.

     
···

       129
       130
        
       

     

       130
       131
        
       in

     

       131
       132
        
       

     

       132
       132
       -
       stdenv.mkDerivation ({

     

       133
       133
       +
       lib.pipe (stdenv.mkDerivation ({

     

       133
       134
        
         pname = "${crossNameAddon}${name}";

     

       134
       135
        
         inherit version;

     

       135
       136
        
       

     
···

       273
       274
        
         };

     

       274
       275
        
       }

     

       275
       276
        
       

     

       276
       276
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       277
       277
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       278
       278
       -
         installTargets = "install-gcc install-target-libgcc";

     

       279
       279
       -
       }

     

       280
       280
       -
       

     

       281
       277
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       282
       282
       -
       )

     

       278
       278
       +
       ))

     

       279
       279
       +
       [

     

       280
       280
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       281
       281
       +
       ]

+5 -5

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

···

       26
       26
        
       , gnused ? null

     

       27
       27
        
       , cloog # unused; just for compat with gcc4, as we override the parameter on some places

     

       28
       28
        
       , buildPackages

     

       29
       29
       +
       , callPackage

     

       29
       30
        
       }:

     

       30
       31
        
       

     

       31
       32
        
       # Note: this package is used for bootstrapping fetchurl, and thus

     
···

       143
       144
        
       

     

       144
       145
        
       in

     

       145
       146
        
       

     

       146
       146
       -
       stdenv.mkDerivation ({

     

       147
       147
       +
       lib.pipe (stdenv.mkDerivation ({

     

       147
       148
        
         pname = "${crossNameAddon}${name}";

     

       148
       149
        
         inherit version;

     

       149
       150
        
       

     
···

       287
       288
        
         };

     

       288
       289
        
       }

     

       289
       290
        
       

     

       290
       290
       -
       // optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {

     

       291
       291
       -
         makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       292
       292
       -
         installTargets = "install-gcc install-target-libgcc";

     

       293
       293
       -
       }

     

       294
       291
        
       

     

       295
       292
        
       // optionalAttrs (enableMultilib) { dontMoveLib64 = true; }

     

       296
       293
        
       )

     

       294
       294
       +
       ) [

     

       295
       295
       +
         (callPackage ../common/libgcc.nix   { inherit version langC langCC langJit targetPlatform hostPlatform crossStageStatic; })

     

       296
       296
       +
       ]

+31 -3

pkgs/development/compilers/gcc/common/libgcc.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
       +
       , version

     

       3
       4
        
       , langC

     

       4
       5
        
       , langCC

     

       5
       6
        
       , langJit

     

       7
       7
       +
       , targetPlatform

     

       8
       8
       +
       , hostPlatform

     

       9
       9
       +
       , crossStageStatic

     

       6
       10
        
       }:

     

       7
       11
        
       

     

       8
       8
       -
       let

     

       12
       12
       +
       drv: lib.pipe drv

     

       13
       13
       +
       

     

       14
       14
       +
       ([

     

       15
       15
       +
       

     

       16
       16
       +
         (pkg: pkg.overrideAttrs (previousAttrs:

     

       17
       17
       +
           lib.optionalAttrs (

     

       18
       18
       +
             targetPlatform != hostPlatform &&

     

       19
       19
       +
             targetPlatform.libc == "msvcrt" &&

     

       20
       20
       +
             crossStageStatic

     

       21
       21
       +
           ) {

     

       22
       22
       +
             makeFlags = [ "all-gcc" "all-target-libgcc" ];

     

       23
       23
       +
             installTargets = "install-gcc install-target-libgcc";

     

       24
       24
       +
           }))

     

       25
       25
       +
       

     

       26
       26
       +
       ] ++

     

       27
       27
       +
       

     

       28
       28
       +
       # nixpkgs did not add the "libgcc" output until gcc11.  In theory

     

       29
       29
       +
       # the following condition can be changed to `true`, but that has not

     

       30
       30
       +
       # been tested.

     

       31
       31
       +
       lib.optional (lib.versionAtLeast version "11.0")

     

       32
       32
       +
       

     

       33
       33
       +
       (let

     

       9
       34
        
         enableLibGccOutput =

     

       10
       35
        
           (with stdenv; targetPlatform == hostPlatform) &&

     

       11
       36
        
           !langJit &&

     

       12
       37
        
           !stdenv.hostPlatform.isDarwin &&

     

       13
       13
       -
           !stdenv.hostPlatform.isStatic;

     

       38
       38
       +
           !stdenv.hostPlatform.isStatic

     

       39
       39
       +
           ;

     

       40
       40
       +
       

     

       14
       41
        
       in

     

       15
       42
        
       (pkg: pkg.overrideAttrs (previousAttrs: lib.optionalAttrs ((!langC) || langJit || enableLibGccOutput) {

     

       16
       43
        
         outputs = previousAttrs.outputs ++ lib.optionals enableLibGccOutput [ "libgcc" ];

     
···

       97
       124
        
           + ''

     

       98
       125
        
             patchelf --set-rpath "" $libgcc/lib/libgcc_s.so.1

     

       99
       126
        
           '');

     

       100
       100
       -
       }))

     

       127
       127
       +
       }))))

     

       128
       128
       +