commit 72d161f548701a2a8dab334dee76b63bccc0f07c · pyrox.dev/nixpkgs

+1 -1

lib/systems/doubles.nix

···

       44
       44
        
         openbsd = filterDoubles predicates.isOpenBSD;

     

       45
       45
        
         unix    = filterDoubles predicates.isUnix;

     

       46
       46
        
       

     

       47
       47
       -
         mesaPlatforms = ["i686-linux" "x86_64-linux" "x86_64-darwin" "armv5tel-linux" "armv6l-linux" "armv7l-linux" "aarch64-linux"];

     

       47
       47
       +
         mesaPlatforms = ["i686-linux" "x86_64-linux" "x86_64-darwin" "armv5tel-linux" "armv6l-linux" "armv7l-linux" "aarch64-linux" "powerpc64le-linux"];

     

       48
       48
        
       }

+8

lib/systems/examples.nix

···

       8
       8
        
         #

     

       9
       9
        
         # Linux

     

       10
       10
        
         #

     

       11
       11
       +
         powernv = {

     

       12
       12
       +
           config = "powerpc64le-unknown-linux-gnu";

     

       13
       13
       +
           platform = platforms.powernv;

     

       14
       14
       +
         };

     

       15
       15
       +
         musl-power = {

     

       16
       16
       +
           config = "powerpc64le-unknown-linux-musl";

     

       17
       17
       +
           platform = platforms.powernv;

     

       18
       18
       +
         };

     

       11
       19
        
       

     

       12
       20
        
         sheevaplug = rec {

     

       13
       21
        
           config = "armv5tel-unknown-linux-gnueabi";

+1

lib/systems/inspect.nix

···

       11
       11
        
           isi686         = { cpu = cpuTypes.i686; };

     

       12
       12
        
           isx86_64       = { cpu = cpuTypes.x86_64; };

     

       13
       13
        
           isPowerPC      = { cpu = cpuTypes.powerpc; };

     

       14
       14
       +
           isPower = { cpu = { family = "power"; }; };

     

       14
       15
        
           isx86          = { cpu = { family = "x86"; }; };

     

       15
       16
        
           isAarch32      = { cpu = { family = "arm"; bits = 32; }; };

     

       16
       17
        
           isAarch64      = { cpu = { family = "arm"; bits = 64; }; };

+2

lib/systems/parse.nix

···

       90
       90
        
           mips64el = { bits = 64; significantByte = littleEndian; family = "mips"; };

     

       91
       91
        
       

     

       92
       92
        
           powerpc  = { bits = 32; significantByte = bigEndian;    family = "power"; };

     

       93
       93
       +
           powerpc64 = { bits = 64; significantByte = bigEndian; family = "power"; };

     

       94
       94
       +
           powerpc64le = { bits = 64; significantByte = littleEndian; family = "power"; };

     

       93
       95
        
       

     

       94
       96
        
           riscv32  = { bits = 32; significantByte = littleEndian; family = "riscv"; };

     

       95
       97
        
           riscv64  = { bits = 64; significantByte = littleEndian; family = "riscv"; };

+17

lib/systems/platforms.nix

···

       20
       20
        
           kernelAutoModules = false;

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
       +
         powernv = {

     

       24
       24
       +
           name = "PowerNV";

     

       25
       25
       +
           kernelArch = "powerpc";

     

       26
       26
       +
           kernelBaseConfig = "powernv_defconfig";

     

       27
       27
       +
           kernelTarget = "zImage";

     

       28
       28
       +
           kernelInstallTarget = "install";

     

       29
       29
       +
           kernelFile = "vmlinux";

     

       30
       30
       +
           kernelAutoModules = true;

     

       31
       31
       +
           # avoid driver/FS trouble arising from unusual page size

     

       32
       32
       +
           kernelExtraConfig = ''

     

       33
       33
       +
             PPC_64K_PAGES n

     

       34
       34
       +
             PPC_4K_PAGES y

     

       35
       35
       +
             IPV6 y

     

       36
       36
       +
           '';

     

       37
       37
       +
         };

     

       38
       38
       +
       

     

       23
       39
        
         ##

     

       24
       40
        
         ## ARM

     

       25
       41
        
         ##

     
···

       458
       474
        
             "armv7l-linux" = armv7l-hf-multiplatform;

     

       459
       475
        
             "aarch64-linux" = aarch64-multiplatform;

     

       460
       476
        
             "mipsel-linux" = fuloong2f_n32;

     

       477
       477
       +
             "powerpc64le-linux" = powernv;

     

       461
       478
        
           }.${system} or pcBase;

     

       462
       479
        
       }

+2 -2

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

···

       171
       171
        
             else if targetPlatform.isWindows then "pe"

     

       172
       172
        
             else "elf" + toString targetPlatform.parsed.cpu.bits;

     

       173
       173
        
           endianPrefix = if targetPlatform.isBigEndian then "big" else "little";

     

       174
       174
       -
           sep = optionalString (!targetPlatform.isMips) "-";

     

       174
       174
       +
           sep = optionalString (!targetPlatform.isMips && !targetPlatform.isPower) "-";

     

       175
       175
        
           arch =

     

       176
       176
        
             /**/ if targetPlatform.isAarch64 then endianPrefix + "aarch64"

     

       177
       177
        
             else if targetPlatform.isAarch32     then endianPrefix + "arm"

     
···

       183
       183
        
                 "mips64"   = "btsmip";

     

       184
       184
        
                 "mips64el" = "ltsmip";

     

       185
       185
        
               }.${targetPlatform.parsed.cpu.name}

     

       186
       186
       -
             else if targetPlatform.isPowerPC then "powerpc"

     

       186
       186
       +
             else if targetPlatform.isPower then if targetPlatform.isBigEndian then "ppc" else "lppc"

     

       187
       187
        
             else if targetPlatform.isSparc then "sparc"

     

       188
       188
        
             else throw "unknown emulation for platform: " + targetPlatform.config;

     

       189
       189
        
           in targetPlatform.platform.bfdEmulation or (fmt + sep + arch);

+2 -1

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

···

       54
       54
        
               url = "https://git.busybox.net/buildroot/plain/package/gcc/7.1.0/0900-remove-selftests.patch?id=11271540bfe6adafbc133caf6b5b902a816f5f02";

     

       55
       55
        
               sha256 = "0mrvxsdwip2p3l17dscpc1x8vhdsciqw1z5q9i6p5g9yg1cqnmgs";

     

       56
       56
        
             })

     

       57
       57
       -
             ++ optional langFortran ../gfortran-driving.patch;

     

       57
       57
       +
             ++ optional langFortran ../gfortran-driving.patch

     

       58
       58
       +
             ++ optional (targetPlatform.libc == "musl" && targetPlatform.isPower) ../ppc-musl.patch;

     

       58
       59
        
       

     

       59
       60
        
           /* Cross-gcc settings (build == host != target) */

     

       60
       61
        
           crossMingw = targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt";

+2 -1

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

···

       49
       49
        
               url = "https://git.busybox.net/buildroot/plain/package/gcc/${version}/0900-remove-selftests.patch?id=11271540bfe6adafbc133caf6b5b902a816f5f02";

     

       50
       50
        
               sha256 = ""; # TODO: uncomment and check hash when available.

     

       51
       51
        
             }) */

     

       52
       52
       -
             ++ optional langFortran ../gfortran-driving.patch;

     

       52
       52
       +
             ++ optional langFortran ../gfortran-driving.patch

     

       53
       53
       +
             ++ optional (targetPlatform.libc == "musl" && targetPlatform.isPower) ../ppc-musl.patch;

     

       53
       54
        
       

     

       54
       55
        
           /* Cross-gcc settings (build == host != target) */

     

       55
       56
        
           crossMingw = targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt";

+3

pkgs/development/compilers/gcc/common/platform-flags.nix

···

       10
       10
        
         (lib.optional (p ? fpu) "--with-fpu=${p.fpu}")

     

       11
       11
        
         (lib.optional (p ? float) "--with-float=${p.float}")

     

       12
       12
        
         (lib.optional (p ? mode) "--with-mode=${p.mode}")

     

       13
       13
       +
         (lib.optional

     

       14
       14
       +
           (let tp = targetPlatform; in tp.isPower && tp.libc == "glibc" && tp.is64bit && tp.isLittleEndian)

     

       15
       15
       +
           "--with-long-double-128")

     

       13
       16
        
       ]

+18

pkgs/development/compilers/gcc/ppc-musl.patch

···

       1
       1
       +
       diff --git a/gcc/config/rs6000/sysv4.h b/gcc/config/rs6000/sysv4.h

     

       2
       2
       +
       index cbee89140dd..e1f26b0a096 100644

     

       3
       3
       +
       --- a/gcc/config/rs6000/sysv4.h

     

       4
       4
       +
       +++ b/gcc/config/rs6000/sysv4.h

     

       5
       5
       +
       @@ -996,13 +996,7 @@ ncrtn.o%s"

     

       6
       6
       +
            { GPLUSPLUS_BACKWARD_INCLUDE_DIR, "G++", 1, 1,	\

     

       7
       7
       +
              GPLUSPLUS_INCLUDE_DIR_ADD_SYSROOT, 0 },

     

       8
       8
       +
        

     

       9
       9
       +
       -#ifdef LOCAL_INCLUDE_DIR

     

       10
       10
       +
       -#define INCLUDE_DEFAULTS_MUSL_LOCAL			\

     

       11
       11
       +
       -    { LOCAL_INCLUDE_DIR, 0, 0, 1, 1, 2 },		\

     

       12
       12
       +
       -    { LOCAL_INCLUDE_DIR, 0, 0, 1, 1, 0 },

     

       13
       13
       +
       -#else

     

       14
       14
       +
        #define INCLUDE_DEFAULTS_MUSL_LOCAL

     

       15
       15
       +
       -#endif

     

       16
       16
       +
        

     

       17
       17
       +
        #ifdef PREFIX_INCLUDE_DIR

     

       18
       18
       +
        #define INCLUDE_DEFAULTS_MUSL_PREFIX			\

+7 -3

pkgs/os-specific/linux/kernel/manual-config.nix

···

       98
       98
        
                   sed -i "$mf" -e 's|/usr/bin/||g ; s|/bin/||g ; s|/sbin/||g'

     

       99
       99
        
               done

     

       100
       100
        
               sed -i Makefile -e 's|= depmod|= ${buildPackages.kmod}/bin/depmod|'

     

       101
       101
       +
               sed -i scripts/ld-version.sh -e "s|/usr/bin/awk|${buildPackages.gawk}/bin/awk|"

     

       101
       102
        
             '';

     

       102
       103
        
       

     

       103
       104
        
             configurePhase = ''

     
···

       145
       146
        
             ++ optional installsFirmware "INSTALL_FW_PATH=$(out)/lib/firmware";

     

       146
       147
        
       

     

       147
       148
        
             # Some image types need special install targets (e.g. uImage is installed with make uinstall)

     

       148
       148
       -
             installTargets = [ (if platform.kernelTarget == "uImage" then "uinstall" else

     

       149
       149
       -
                                 if platform.kernelTarget == "zImage" || platform.kernelTarget == "Image.gz" then "zinstall" else

     

       150
       150
       -
                                 "install") ];

     

       149
       149
       +
             installTargets = [ (

     

       150
       150
       +
               if platform ? kernelInstallTarget then platform.kernelInstallTarget

     

       151
       151
       +
               else if platform.kernelTarget == "uImage" then "uinstall"

     

       152
       152
       +
               else if platform.kernelTarget == "zImage" || platform.kernelTarget == "Image.gz" then "zinstall"

     

       153
       153
       +
               else "install"

     

       154
       154
       +
             ) ];

     

       151
       155
        
       

     

       152
       156
        
             postInstall = (optionalString installsFirmware ''

     

       153
       157
        
               mkdir -p $out/lib/firmware

+3 -2

pkgs/os-specific/linux/musl/default.nix

···

       1
       1
       -
       { stdenv, lib, fetchurl

     

       1
       1
       +
       { stdenv, lib, fetchurl, hostPlatform

     

       2
       2
        
       , linuxHeaders ? null

     

       3
       3
        
       , useBSDCompatHeaders ? true

     

       4
       4
        
       }:

     
···

       61
       61
        
           configureFlagsArray+=("--syslibdir=$out/lib")

     

       62
       62
        
         '';

     

       63
       63
        
       

     

       64
       64
       +
         CFLAGS="-fstack-protector-strong" + lib.optionalString hostPlatform.isPower " -mlong-double-64";

     

       65
       65
       +
       

     

       64
       66
        
         configureFlags = [

     

       65
       67
        
           "--enable-shared"

     

       66
       68
        
           "--enable-static"

     

       67
       69
        
           "--enable-debug"

     

       68
       68
       -
           "CFLAGS=-fstack-protector-strong"

     

       69
       70
        
           "--enable-wrapper=all"

     

       70
       71
        
         ];

     

       71
       72

+1

pkgs/stdenv/default.nix

···

       47
       47
        
           "aarch64-linux" = stagesLinux;

     

       48
       48
        
           "mipsel-linux" = stagesLinux;

     

       49
       49
        
           "powerpc-linux" = /* stagesLinux */ stagesNative;

     

       50
       50
       +
           "powerpc64le-linux" = stagesLinux;

     

       50
       51
        
           "x86_64-darwin" = stagesDarwin;

     

       51
       52
        
           "x86_64-solaris" = stagesNix;

     

       52
       53
        
           "i686-cygwin" = stagesNative;

+3

pkgs/stdenv/linux/bootstrap-tools/scripts/unpack-bootstrap-tools.sh

···

       9
       9
        
       if test -f $out/lib/ld.so.?; then

     

       10
       10
        
          # MIPS case

     

       11
       11
        
          LD_BINARY=$out/lib/ld.so.?

     

       12
       12
       +
       elif test -f $out/lib/ld64.so.?; then

     

       13
       13
       +
          # ppc64(le)

     

       14
       14
       +
          LD_BINARY=$out/lib/ld64.so.?

     

       12
       15
        
       else

     

       13
       16
        
          # i686, x86_64 and armv5tel

     

       14
       17
        
          LD_BINARY=$out/lib/ld-*so.?

+2

pkgs/stdenv/linux/default.nix

···

       16
       16
        
             "armv7l-linux" = import ./bootstrap-files/armv7l.nix;

     

       17
       17
        
             "aarch64-linux" = import ./bootstrap-files/aarch64.nix;

     

       18
       18
        
             "mipsel-linux" = import ./bootstrap-files/loongson2f.nix;

     

       19
       19
       +
             "powerpc64le-linux" = import ./bootstrap-files/ppc64le.nix;

     

       19
       20
        
           };

     

       20
       21
        
           "musl" = {

     

       21
       22
        
             "aarch64-linux" = import ./bootstrap-files/aarch64-musl.nix;

     

       22
       23
        
             "armv6l-linux"  = import ./bootstrap-files/armv6l-musl.nix;

     

       23
       24
        
             "x86_64-linux"  = import ./bootstrap-files/x86_64-musl.nix;

     

       25
       25
       +
             "powerpc64le-linux" = import ./bootstrap-files/ppc64le-musl.nix;

     

       24
       26
        
           };

     

       25
       27
        
         };

     

       26
       28
        
         archLookupTable = table.${localSystem.libc}

+15 -13

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

···

       5
       5
        
           localSystem = { inherit system; };

     

       6
       6
        
           inherit crossSystem;

     

       7
       7
        
         };

     

       8
       8
       -
       

     

       9
       9
       -
       in with (import ../../../lib).systems.examples; {

     

       10
       10
       -
         armv5tel   = make sheevaplug;

     

       11
       11
       -
         scaleway   = make scaleway-c1;

     

       12
       12
       -
         pogoplug4  = make pogoplug4;

     

       13
       13
       -
         armv6l     = make raspberryPi;

     

       14
       14
       -
         armv7l     = make armv7l-hf-multiplatform;

     

       15
       15
       -
         aarch64    = make aarch64-multiplatform;

     

       16
       16
       -
         x86_64-musl  = make musl64;

     

       17
       17
       -
         armv6l-musl  = make muslpi;

     

       18
       18
       -
         aarch64-musl = make aarch64-multiplatform-musl;

     

       19
       19
       -
         riscv64 = make riscv64;

     

       20
       20
       -
       }

     

       8
       8
       +
         lib = import ../../../lib;

     

       9
       9
       +
       in lib.mapAttrs (n: make) (with lib.systems.examples; {

     

       10
       10
       +
         armv5tel   = sheevaplug;

     

       11
       11
       +
         scaleway   = scaleway-c1;

     

       12
       12
       +
         pogoplug4  = pogoplug4;

     

       13
       13
       +
         armv6l     = raspberryPi;

     

       14
       14
       +
         armv7l     = armv7l-hf-multiplatform;

     

       15
       15
       +
         aarch64    = aarch64-multiplatform;

     

       16
       16
       +
         x86_64-musl  = musl64;

     

       17
       17
       +
         armv6l-musl  = muslpi;

     

       18
       18
       +
         aarch64-musl = aarch64-multiplatform-musl;

     

       19
       19
       +
         riscv64 = riscv64;

     

       20
       20
       +
         powerpc64le = powernv;

     

       21
       21
       +
         powerpc64le-musl = musl-power;

     

       22
       22
       +
       })