commit 948c8dc474954fce1e340308062a3af0a66610ac · pyrox.dev/nixpkgs

+1 -1

lib/systems/doubles.nix

···

       26
       26
        
       

     

       27
       27
        
         none = [];

     

       28
       28
        
       

     

       29
       29
       -
         arm     = filterDoubles predicates.isArm;

     

       29
       29
       +
         arm     = filterDoubles predicates.isAarch32;

     

       30
       30
        
         aarch64 = filterDoubles predicates.isAarch64;

     

       31
       31
        
         x86     = filterDoubles predicates.isx86;

     

       32
       32
        
         i686    = filterDoubles predicates.isi686;

+1 -1

lib/systems/for-meta.nix

···

       7
       7
        
         all     = [ {} ]; # `{}` matches anything

     

       8
       8
        
         none    = [];

     

       9
       9
        
       

     

       10
       10
       -
         arm     = [ patterns.isArm ];

     

       10
       10
       +
         arm     = [ patterns.isAarch32 ];

     

       11
       11
        
         aarch64 = [ patterns.isAarch64 ];

     

       12
       12
        
         x86     = [ patterns.isx86 ];

     

       13
       13
        
         i686    = [ patterns.isi686 ];

+5 -2

lib/systems/inspect.nix

···

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

     

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

     

       11
       11
        
           isx86          = { cpu = { family = "x86"; }; };

     

       12
       12
       -
           isArm          = { cpu = { family = "arm"; }; };

     

       13
       13
       -
           isAarch64      = { cpu = { family = "aarch64"; }; };

     

       12
       12
       +
           isAarch32      = { cpu = { family = "arm"; bits = 32; }; };

     

       13
       13
       +
           isAarch64      = { cpu = { family = "arm"; bits = 64; }; };

     

       14
       14
        
           isMips         = { cpu = { family = "mips"; }; };

     

       15
       15
        
           isRiscV        = { cpu = { family = "riscv"; }; };

     

       16
       16
        
           isWasm         = { cpu = { family = "wasm"; }; };

     
···

       41
       41
        
       

     

       42
       42
        
           isEfi          = map (family: { cpu.family = family; })

     

       43
       43
        
                              [ "x86" "arm" "aarch64" ];

     

       44
       44
       +
       

     

       45
       45
       +
           # Deprecated

     

       46
       46
       +
           isArm = isAarch32;

     

       44
       47
        
         };

     

       45
       48
        
       

     

       46
       49
        
         matchAnyAttrs = patterns:

+1 -1

lib/systems/parse.nix

···

       72
       72
        
           armv6l   = { bits = 32; significantByte = littleEndian; family = "arm"; };

     

       73
       73
        
           armv7a   = { bits = 32; significantByte = littleEndian; family = "arm"; };

     

       74
       74
        
           armv7l   = { bits = 32; significantByte = littleEndian; family = "arm"; };

     

       75
       75
       -
           aarch64  = { bits = 64; significantByte = littleEndian; family = "aarch64"; };

     

       75
       75
       +
           aarch64  = { bits = 64; significantByte = littleEndian; family = "arm"; };

     

       76
       76
        
           i686     = { bits = 32; significantByte = littleEndian; family = "x86"; };

     

       77
       77
        
           x86_64   = { bits = 64; significantByte = littleEndian; family = "x86"; };

     

       78
       78
        
           mips     = { bits = 32; significantByte = bigEndian;    family = "mips"; };

+1 -1

nixos/lib/qemu-flags.nix

···

       9
       9
        
           ];

     

       10
       10
        
       

     

       11
       11
        
         qemuSerialDevice = if pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64 then "ttyS0"

     

       12
       12
       -
               else if pkgs.stdenv.isArm || pkgs.stdenv.isAarch64 then "ttyAMA0"

     

       12
       12
       +
               else if pkgs.stdenv.isAarch32 || pkgs.stdenv.isAarch64 then "ttyAMA0"

     

       13
       13
        
               else throw "Unknown QEMU serial device for system '${pkgs.stdenv.system}'";

     

       14
       14
        
       

     

       15
       15
        
         qemuBinary = qemuPkg: {

+2 -2

nixos/modules/config/gnu.nix

···

       26
       26
        
               nano zile

     

       27
       27
        
               texinfo # for the stand-alone Info reader

     

       28
       28
        
             ]

     

       29
       29
       -
             ++ stdenv.lib.optional (!stdenv.isArm) grub2;

     

       29
       29
       +
             ++ stdenv.lib.optional (!stdenv.isAarch32) grub2;

     

       30
       30
        
       

     

       31
       31
        
       

     

       32
       32
        
           # GNU GRUB, where available.

     

       33
       33
       -
           boot.loader.grub.enable = !pkgs.stdenv.isArm;

     

       33
       33
       +
           boot.loader.grub.enable = !pkgs.stdenv.isAarch32;

     

       34
       34
        
           boot.loader.grub.version = 2;

     

       35
       35
        
       

     

       36
       36
        
           # GNU lsh.

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       437
       437
        
           # FIXME: Consolidate this one day.

     

       438
       438
        
           virtualisation.qemu.options = mkMerge [

     

       439
       439
        
             (mkIf (pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) [ "-vga std" "-usb" "-device usb-tablet,bus=usb-bus.0" ])

     

       440
       440
       -
             (mkIf (pkgs.stdenv.isArm || pkgs.stdenv.isAarch64) [ "-device virtio-gpu-pci" "-device usb-ehci,id=usb0" "-device usb-kbd" "-device usb-tablet" ])

     

       440
       440
       +
             (mkIf (pkgs.stdenv.isAarch32 || pkgs.stdenv.isAarch64) [ "-device virtio-gpu-pci" "-device usb-ehci,id=usb0" "-device usb-kbd" "-device usb-tablet" ])

     

       441
       441
        
           ];

     

       442
       442
        
       

     

       443
       443
        
           # Mount the host filesystem via 9P, and bind-mount the Nix store

+1 -1

pkgs/applications/audio/sunvox/default.nix

···

       5
       5
        
         arch =

     

       6
       6
        
           if stdenv.isAarch64

     

       7
       7
        
           then "arm64"

     

       8
       8
       -
           else if stdenv.isArm

     

       8
       8
       +
           else if stdenv.isAarch32

     

       9
       9
        
           then "arm_armhf_raspberry_pi"

     

       10
       10
        
           else if stdenv.is64bit

     

       11
       11
        
           then "x86_64"

+1 -1

pkgs/applications/networking/instant-messengers/toxic/default.nix

···

       18
       18
        
       

     

       19
       19
        
         buildInputs = [

     

       20
       20
        
           libtoxcore libsodium ncurses curl gdk_pixbuf libnotify

     

       21
       21
       -
         ] ++ stdenv.lib.optionals (!stdenv.isArm) [

     

       21
       21
       +
         ] ++ stdenv.lib.optionals (!stdenv.isAarch32) [

     

       22
       22
        
           openal libopus libvpx freealut libqrencode

     

       23
       23
        
         ];

     

       24
       24
        
         nativeBuildInputs = [ pkgconfig libconfig ];

+3 -3

pkgs/applications/virtualization/qemu/default.nix

···

       4
       4
        
       , makeWrapper

     

       5
       5
        
       , attr, libcap, libcap_ng

     

       6
       6
        
       , CoreServices, Cocoa, rez, setfile

     

       7
       7
       -
       , numaSupport ? stdenv.isLinux && !stdenv.isArm, numactl

     

       7
       7
       +
       , numaSupport ? stdenv.isLinux && !stdenv.isAarch32, numactl

     

       8
       8
        
       , seccompSupport ? stdenv.isLinux, libseccomp

     

       9
       9
        
       , pulseSupport ? !stdenv.isDarwin, libpulseaudio

     

       10
       10
        
       , sdlSupport ? !stdenv.isDarwin, SDL2

     
···

       29
       29
        
       

     

       30
       30
        
         hostCpuTargets = if stdenv.isx86_64 then "i386-softmmu,x86_64-softmmu"

     

       31
       31
        
                          else if stdenv.isi686 then "i386-softmmu"

     

       32
       32
       -
                          else if stdenv.isArm then "arm-softmmu"

     

       32
       32
       +
                          else if stdenv.isAarch32 then "arm-softmmu"

     

       33
       33
        
                          else if stdenv.isAarch64 then "aarch64-softmmu"

     

       34
       34
        
                          else throw "Don't know how to build a 'hostCpuOnly = true' QEMU";

     

       35
       35
        
       in

     
···

       135
       135
        
         postInstall =

     

       136
       136
        
           if stdenv.isx86_64       then ''makeWrapper $out/bin/qemu-system-x86_64  $out/bin/qemu-kvm --add-flags "\$([ -e /dev/kvm ] && echo -enable-kvm)"''

     

       137
       137
        
           else if stdenv.isi686    then ''makeWrapper $out/bin/qemu-system-i386    $out/bin/qemu-kvm --add-flags "\$([ -e /dev/kvm ] && echo -enable-kvm)"''

     

       138
       138
       -
           else if stdenv.isArm     then ''makeWrapper $out/bin/qemu-system-arm     $out/bin/qemu-kvm --add-flags "\$([ -e /dev/kvm ] && echo -enable-kvm)"''

     

       138
       138
       +
           else if stdenv.isAarch32     then ''makeWrapper $out/bin/qemu-system-arm     $out/bin/qemu-kvm --add-flags "\$([ -e /dev/kvm ] && echo -enable-kvm)"''

     

       139
       139
        
           else if stdenv.isAarch64 then ''makeWrapper $out/bin/qemu-system-aarch64 $out/bin/qemu-kvm --add-flags "\$([ -e /dev/kvm ] && echo -enable-kvm)"''

     

       140
       140
        
           else "";

     

       141
       141

+2 -2

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

···

       57
       57
        
           else if targetPlatform.system == "i686-linux"     then "${libc_lib}/lib/ld-linux.so.2"

     

       58
       58
        
           else if targetPlatform.system == "x86_64-linux"   then "${libc_lib}/lib/ld-linux-x86-64.so.2"

     

       59
       59
        
           # ARM with a wildcard, which can be "" or "-armhf".

     

       60
       60
       -
           else if (with targetPlatform; isArm && isLinux)   then "${libc_lib}/lib/ld-linux*.so.3"

     

       60
       60
       +
           else if (with targetPlatform; isAarch32 && isLinux)   then "${libc_lib}/lib/ld-linux*.so.3"

     

       61
       61
        
           else if targetPlatform.system == "aarch64-linux"  then "${libc_lib}/lib/ld-linux-aarch64.so.1"

     

       62
       62
        
           else if targetPlatform.system == "powerpc-linux"  then "${libc_lib}/lib/ld.so.1"

     

       63
       63
        
           else if targetPlatform.isMips                     then "${libc_lib}/lib/ld.so.1"

     
···

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

     

       177
       177
        
           arch =

     

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

     

       179
       179
       -
             else if targetPlatform.isArm     then endianPrefix + "arm"

     

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

     

       180
       180
        
             else if targetPlatform.isx86_64  then "x86-64"

     

       181
       181
        
             else if targetPlatform.isi686    then "i386"

     

       182
       182
        
             else if targetPlatform.isMips    then {

+1 -1

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

···

       289
       289
        
         # TODO(@Ericson2314): Always pass "--target" and always prefix.

     

       290
       290
        
         configurePlatforms =

     

       291
       291
        
           # TODO(@Ericson2314): Figure out what's going wrong with Arm

     

       292
       292
       -
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isArm

     

       292
       292
       +
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isAarch32

     

       293
       293
        
           then []

     

       294
       294
        
           else [ "build" "host" ] ++ stdenv.lib.optional (targetPlatform != hostPlatform) "target";

     

       295
       295

+1 -1

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

···

       298
       298
        
         # TODO(@Ericson2314): Always pass "--target" and always prefix.

     

       299
       299
        
         configurePlatforms =

     

       300
       300
        
           # TODO(@Ericson2314): Figure out what's going wrong with Arm

     

       301
       301
       -
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isArm

     

       301
       301
       +
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isAarch32

     

       302
       302
        
           then []

     

       303
       303
        
           else [ "build" "host" ] ++ stdenv.lib.optional (targetPlatform != hostPlatform) "target";

     

       304
       304

+1 -1

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

···

       318
       318
        
         # TODO(@Ericson2314): Always pass "--target" and always prefix.

     

       319
       319
        
         configurePlatforms =

     

       320
       320
        
           # TODO(@Ericson2314): Figure out what's going wrong with Arm

     

       321
       321
       -
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isArm

     

       321
       321
       +
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isAarch32

     

       322
       322
        
           then []

     

       323
       323
        
           else [ "build" "host" ] ++ stdenv.lib.optional (targetPlatform != hostPlatform) "target";

     

       324
       324

+1 -1

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

···

       322
       322
        
         # TODO(@Ericson2314): Always pass "--target" and always prefix.

     

       323
       323
        
         configurePlatforms =

     

       324
       324
        
           # TODO(@Ericson2314): Figure out what's going wrong with Arm

     

       325
       325
       -
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isArm

     

       325
       325
       +
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isAarch32

     

       326
       326
        
           then []

     

       327
       327
        
           else [ "build" "host" ] ++ stdenv.lib.optional (targetPlatform != hostPlatform) "target";

     

       328
       328

+1 -1

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

···

       327
       327
        
         # TODO(@Ericson2314): Always pass "--target" and always prefix.

     

       328
       328
        
         configurePlatforms =

     

       329
       329
        
           # TODO(@Ericson2314): Figure out what's going wrong with Arm

     

       330
       330
       -
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isArm

     

       330
       330
       +
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isAarch32

     

       331
       331
        
           then []

     

       332
       332
        
           else [ "build" "host" ] ++ stdenv.lib.optional (targetPlatform != hostPlatform) "target";

     

       333
       333

+1 -1

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

···

       290
       290
        
         # TODO(@Ericson2314): Always pass "--target" and always prefix.

     

       291
       291
        
         configurePlatforms =

     

       292
       292
        
           # TODO(@Ericson2314): Figure out what's going wrong with Arm

     

       293
       293
       -
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isArm

     

       293
       293
       +
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isAarch32

     

       294
       294
        
           then []

     

       295
       295
        
           else [ "build" "host" ] ++ stdenv.lib.optional (targetPlatform != hostPlatform) "target";

     

       296
       296

+1 -1

pkgs/development/compilers/ghc/7.10.3-binary.nix

···

       43
       43
        
           or (throw "cannot bootstrap GHC on this platform"));

     

       44
       44
        
       

     

       45
       45
        
         nativeBuildInputs = [ perl ];

     

       46
       46
       -
         buildInputs = stdenv.lib.optionals stdenv.targetPlatform.isArm [ llvm_35 ];

     

       46
       46
       +
         buildInputs = stdenv.lib.optionals stdenv.targetPlatform.isAarch32 [ llvm_35 ];

     

       47
       47
        
       

     

       48
       48
        
         # Cannot patchelf beforehand due to relative RPATHs that anticipate

     

       49
       49
        
         # the final install location/

+1 -1

pkgs/development/compilers/ghc/8.2.1-binary.nix

···

       46
       46
        
           or (throw "cannot bootstrap GHC on this platform"));

     

       47
       47
        
       

     

       48
       48
        
         nativeBuildInputs = [ perl ];

     

       49
       49
       -
         buildInputs = stdenv.lib.optionals (stdenv.targetPlatform.isArm || stdenv.targetPlatform.isAarch64) [ llvm_39 ];

     

       49
       49
       +
         buildInputs = stdenv.lib.optionals (stdenv.targetPlatform.isAarch32 || stdenv.targetPlatform.isAarch64) [ llvm_39 ];

     

       50
       50
        
       

     

       51
       51
        
         # Cannot patchelf beforehand due to relative RPATHs that anticipate

     

       52
       52
        
         # the final install location/

+3 -3

pkgs/development/compilers/ghc/8.2.2.nix

···

       26
       26
        
         enableShared ?

     

       27
       27
        
           !(targetPlatform.isDarwin

     

       28
       28
        
             # On iOS, dynamic linking is not supported

     

       29
       29
       -
             && (targetPlatform.isAarch64 || targetPlatform.isArm))

     

       29
       29
       +
             && (targetPlatform.isAarch64 || targetPlatform.isAarch32))

     

       30
       30
        
       , # Whether to backport https://phabricator.haskell.org/D4388 for

     

       31
       31
        
         # deterministic profiling symbol names, at the cost of a slightly

     

       32
       32
        
         # non-standard GHC API

     
···

       109
       109
        
           export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

     

       110
       110
        
           export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

     

       111
       111
        
           # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

     

       112
       112
       -
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isArm ".gold"}"

     

       112
       112
       +
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isAarch32 ".gold"}"

     

       113
       113
        
           export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

     

       114
       114
        
           export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

     

       115
       115
        
           export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

     
···

       138
       138
        
           "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

     

       139
       139
        
         ] ++ stdenv.lib.optionals (targetPlatform != hostPlatform) [

     

       140
       140
        
           "--enable-bootstrap-with-devel-snapshot"

     

       141
       141
       -
         ] ++ stdenv.lib.optionals (targetPlatform.isArm) [

     

       141
       141
       +
         ] ++ stdenv.lib.optionals (targetPlatform.isAarch32) [

     

       142
       142
        
           "CFLAGS=-fuse-ld=gold"

     

       143
       143
        
           "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

     

       144
       144
        
           "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

+2 -2

pkgs/development/compilers/ghc/8.4.1.nix

···

       106
       106
        
           export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

     

       107
       107
        
           export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

     

       108
       108
        
           # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

     

       109
       109
       -
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isArm ".gold"}"

     

       109
       109
       +
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isAarch32 ".gold"}"

     

       110
       110
        
           export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

     

       111
       111
        
           export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

     

       112
       112
        
           export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

     
···

       138
       138
        
           "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

     

       139
       139
        
         ] ++ stdenv.lib.optionals (targetPlatform != hostPlatform) [

     

       140
       140
        
           "--enable-bootstrap-with-devel-snapshot"

     

       141
       141
       -
         ] ++ stdenv.lib.optionals (targetPlatform.isArm) [

     

       141
       141
       +
         ] ++ stdenv.lib.optionals (targetPlatform.isAarch32) [

     

       142
       142
        
           "CFLAGS=-fuse-ld=gold"

     

       143
       143
        
           "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

     

       144
       144
        
           "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

+2 -2

pkgs/development/compilers/ghc/8.4.2.nix

···

       91
       91
        
           export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

     

       92
       92
        
           export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

     

       93
       93
        
           # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

     

       94
       94
       -
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isArm ".gold"}"

     

       94
       94
       +
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isAarch32 ".gold"}"

     

       95
       95
        
           export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

     

       96
       96
        
           export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

     

       97
       97
        
           export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

     
···

       120
       120
        
           "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

     

       121
       121
        
         ] ++ stdenv.lib.optionals (targetPlatform != hostPlatform) [

     

       122
       122
        
           "--enable-bootstrap-with-devel-snapshot"

     

       123
       123
       -
         ] ++ stdenv.lib.optionals (targetPlatform.isArm) [

     

       123
       123
       +
         ] ++ stdenv.lib.optionals (targetPlatform.isAarch32) [

     

       124
       124
        
           "CFLAGS=-fuse-ld=gold"

     

       125
       125
        
           "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

     

       126
       126
        
           "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

+2 -2

pkgs/development/compilers/ghc/head.nix

···

       93
       93
        
           export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

     

       94
       94
        
           export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

     

       95
       95
        
           # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

     

       96
       96
       -
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isArm ".gold"}"

     

       96
       96
       +
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${stdenv.lib.optionalString targetPlatform.isAarch32 ".gold"}"

     

       97
       97
        
           export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

     

       98
       98
        
           export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

     

       99
       99
        
           export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

     
···

       125
       125
        
           "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"

     

       126
       126
        
         ] ++ stdenv.lib.optionals (targetPlatform != hostPlatform) [

     

       127
       127
        
           "--enable-bootstrap-with-devel-snapshot"

     

       128
       128
       -
         ] ++ stdenv.lib.optionals (targetPlatform.isArm) [

     

       128
       128
       +
         ] ++ stdenv.lib.optionals (targetPlatform.isAarch32) [

     

       129
       129
        
           "CFLAGS=-fuse-ld=gold"

     

       130
       130
        
           "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

     

       131
       131
        
           "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

+2 -2

pkgs/development/compilers/go/1.10.nix

···

       85
       85
        
       

     

       86
       86
        
         '' + optionalString stdenv.isLinux ''

     

       87
       87
        
           sed -i 's,/usr/share/zoneinfo/,${tzdata}/share/zoneinfo/,' src/time/zoneinfo_unix.go

     

       88
       88
       -
         '' + optionalString stdenv.isArm ''

     

       88
       88
       +
         '' + optionalString stdenv.isAarch32 ''

     

       89
       89
        
           sed -i '/TestCurrent/areturn' src/os/user/user_test.go

     

       90
       90
        
           echo '#!${stdenv.shell}' > misc/cgo/testplugin/test.bash

     

       91
       91
        
         '' + optionalString stdenv.isDarwin ''

     
···

       130
       130
        
         GOARCH = if stdenv.isDarwin then "amd64"

     

       131
       131
        
                  else if stdenv.system == "i686-linux" then "386"

     

       132
       132
        
                  else if stdenv.system == "x86_64-linux" then "amd64"

     

       133
       133
       -
                  else if stdenv.isArm then "arm"

     

       133
       133
       +
                  else if stdenv.isAarch32 then "arm"

     

       134
       134
        
                  else if stdenv.isAarch64 then "arm64"

     

       135
       135
        
                  else throw "Unsupported system";

     

       136
       136
        
         GOARM = optionalString (stdenv.system == "armv5tel-linux") "5";

+1 -1

pkgs/development/compilers/go/1.4.nix

···

       130
       130
        
         GOARCH = if stdenv.isDarwin then "amd64"

     

       131
       131
        
                  else if stdenv.system == "i686-linux" then "386"

     

       132
       132
        
                  else if stdenv.system == "x86_64-linux" then "amd64"

     

       133
       133
       -
                  else if stdenv.isArm then "arm"

     

       133
       133
       +
                  else if stdenv.isAarch32 then "arm"

     

       134
       134
        
                  else throw "Unsupported system";

     

       135
       135
        
         GOARM = stdenv.lib.optionalString (stdenv.system == "armv5tel-linux") "5";

     

       136
       136
        
         GO386 = 387; # from Arch: don't assume sse2 on i686

+2 -2

pkgs/development/compilers/go/1.9.nix

···

       85
       85
        
       

     

       86
       86
        
         '' + optionalString stdenv.isLinux ''

     

       87
       87
        
           sed -i 's,/usr/share/zoneinfo/,${tzdata}/share/zoneinfo/,' src/time/zoneinfo_unix.go

     

       88
       88
       -
         '' + optionalString stdenv.isArm ''

     

       88
       88
       +
         '' + optionalString stdenv.isAarch32 ''

     

       89
       89
        
           sed -i '/TestCurrent/areturn' src/os/user/user_test.go

     

       90
       90
        
           echo '#!${stdenv.shell}' > misc/cgo/testplugin/test.bash

     

       91
       91
        
         '' + optionalString stdenv.isDarwin ''

     
···

       132
       132
        
         GOARCH = if stdenv.isDarwin then "amd64"

     

       133
       133
        
                  else if stdenv.system == "i686-linux" then "386"

     

       134
       134
        
                  else if stdenv.system == "x86_64-linux" then "amd64"

     

       135
       135
       -
                  else if stdenv.isArm then "arm"

     

       135
       135
       +
                  else if stdenv.isAarch32 then "arm"

     

       136
       136
        
                  else if stdenv.isAarch64 then "arm64"

     

       137
       137
        
                  else throw "Unsupported system";

     

       138
       138
        
         GOARM = optionalString (stdenv.system == "armv5tel-linux") "5";

+1 -1

pkgs/development/compilers/ocaml/3.12.1.nix

···

       1
       1
        
       { stdenv, fetchurl, ncurses, xlibsWrapper }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
          useX11 = !stdenv.isArm && !stdenv.isMips;

     

       4
       4
       +
          useX11 = !stdenv.isAarch32 && !stdenv.isMips;

     

       5
       5
        
          useNativeCompilers = !stdenv.isMips;

     

       6
       6
        
          inherit (stdenv.lib) optionals optionalString;

     

       7
       7
        
       in

+1 -1

pkgs/development/compilers/ocaml/4.00.1.nix

···

       1
       1
        
       { stdenv, fetchurl, ncurses, xlibsWrapper }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
          useX11 = !stdenv.isArm && !stdenv.isMips;

     

       4
       4
       +
          useX11 = !stdenv.isAarch32 && !stdenv.isMips;

     

       5
       5
        
          useNativeCompilers = !stdenv.isMips;

     

       6
       6
        
          inherit (stdenv.lib) optionals optionalString;

     

       7
       7
        
       in

+2 -2

pkgs/development/compilers/ocaml/generic.nix

···

       7
       7
        
         real_url = if url == null then

     

       8
       8
        
           "http://caml.inria.fr/pub/distrib/ocaml-${versionNoPatch}/ocaml-${version}.tar.xz"

     

       9
       9
        
         else url;

     

       10
       10
       -
         safeX11 = stdenv: !(stdenv.isArm || stdenv.isMips);

     

       10
       10
       +
         safeX11 = stdenv: !(stdenv.isAarch32 || stdenv.isMips);

     

       11
       11
        
       in

     

       12
       12
        
       

     

       13
       13
        
       { stdenv, fetchurl, ncurses, buildEnv

     
···

       15
       15
        
       , flambdaSupport ? false

     

       16
       16
        
       }:

     

       17
       17
        
       

     

       18
       18
       -
       assert useX11 -> !stdenv.isArm && !stdenv.isMips;

     

       18
       18
       +
       assert useX11 -> !stdenv.isAarch32 && !stdenv.isMips;

     

       19
       19
        
       assert flambdaSupport -> stdenv.lib.versionAtLeast version "4.03";

     

       20
       20
        
       

     

       21
       21
        
       let

+1 -1

pkgs/development/compilers/sbcl/bootstrap.nix

···

       65
       65
        
             --add-flags "--core $out/share/sbcl/sbcl.core"

     

       66
       66
        
         '';

     

       67
       67
        
       

     

       68
       68
       -
         postFixup = stdenv.lib.optionalString (!stdenv.isArm && stdenv.isLinux) ''

     

       68
       68
       +
         postFixup = stdenv.lib.optionalString (!stdenv.isAarch32 && stdenv.isLinux) ''

     

       69
       69
        
           patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) $out/share/sbcl/sbcl

     

       70
       70
        
         '';

     

       71
       71

+1 -1

pkgs/development/compilers/sbcl/default.nix

···

       26
       26
        
                      (setf features (remove x features))))

     

       27
       27
        
           ''

     

       28
       28
        
           + (if threadSupport then "(enable :sb-thread)" else "(disable :sb-thread)")

     

       29
       29
       -
           + stdenv.lib.optionalString stdenv.isArm "(enable :arm)"

     

       29
       29
       +
           + stdenv.lib.optionalString stdenv.isAarch32 "(enable :arm)"

     

       30
       30
        
           + ''

     

       31
       31
        
             )) " > customize-target-features.lisp

     

       32
       32

+5 -5

pkgs/development/haskell-modules/configuration-common.nix

···

       932
       932
        
         JuicyPixels = dontHaddock super.JuicyPixels;

     

       933
       933
        
       

     

       934
       934
        
         # aarch64 and armv7l fixes.

     

       935
       935
       -
         happy = if (pkgs.stdenv.hostPlatform.isArm || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.happy else super.happy; # Similar to https://ghc.haskell.org/trac/ghc/ticket/13062

     

       936
       936
       -
         hashable = if (pkgs.stdenv.hostPlatform.isArm || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.hashable else super.hashable; # https://github.com/tibbe/hashable/issues/95

     

       937
       937
       -
         servant-docs = if (pkgs.stdenv.hostPlatform.isArm || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.servant-docs else super.servant-docs;

     

       938
       938
       -
         servant-swagger = if (pkgs.stdenv.hostPlatform.isArm || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.servant-swagger else super.servant-swagger;

     

       939
       939
       -
         swagger2 = if (pkgs.stdenv.hostPlatform.isArm || pkgs.stdenv.hostPlatform.isAarch64) then dontHaddock (dontCheck super.swagger2) else super.swagger2;

     

       935
       935
       +
         happy = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.happy else super.happy; # Similar to https://ghc.haskell.org/trac/ghc/ticket/13062

     

       936
       936
       +
         hashable = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.hashable else super.hashable; # https://github.com/tibbe/hashable/issues/95

     

       937
       937
       +
         servant-docs = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.servant-docs else super.servant-docs;

     

       938
       938
       +
         servant-swagger = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.servant-swagger else super.servant-swagger;

     

       939
       939
       +
         swagger2 = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontHaddock (dontCheck super.swagger2) else super.swagger2;

     

       940
       940
        
       

     

       941
       941
        
         # Tries to read a file it is not allowed to in the test suite

     

       942
       942
        
         load-env = dontCheck super.load-env;

+1 -1

pkgs/development/haskell-modules/generic-builder.nix

···

       136
       136
        
           (optionalString (enableSharedExecutables && stdenv.isDarwin) "--ghc-option=-optl=-Wl,-headerpad_max_install_names")

     

       137
       137
        
           (optionalString enableParallelBuilding "--ghc-option=-j$NIX_BUILD_CORES")

     

       138
       138
        
           (optionalString useCpphs "--with-cpphs=${cpphs}/bin/cpphs --ghc-options=-cpp --ghc-options=-pgmP${cpphs}/bin/cpphs --ghc-options=-optP--cpp")

     

       139
       139
       -
           (enableFeature (enableDeadCodeElimination && !hostPlatform.isArm && !hostPlatform.isAarch64 && (versionAtLeast "8.0.1" ghc.version)) "split-objs")

     

       139
       139
       +
           (enableFeature (enableDeadCodeElimination && !hostPlatform.isAarch32 && !hostPlatform.isAarch64 && (versionAtLeast "8.0.1" ghc.version)) "split-objs")

     

       140
       140
        
           (enableFeature enableLibraryProfiling "library-profiling")

     

       141
       141
        
           (optionalString ((enableExecutableProfiling || enableLibraryProfiling) && versionOlder "8" ghc.version) "--profiling-detail=${profilingDetail}")

     

       142
       142
        
           (enableFeature enableExecutableProfiling (if versionOlder ghc.version "8" then "executable-profiling" else "profiling"))

+1 -1

pkgs/development/interpreters/perl/default.nix

···

       86
       86
        
       

     

       87
       87
        
           preConfigure = optionalString (!crossCompiling) ''

     

       88
       88
        
               configureFlags="$configureFlags -Dprefix=$out -Dman1dir=$out/share/man/man1 -Dman3dir=$out/share/man/man3"

     

       89
       89
       -
             '' + optionalString (stdenv.isArm || stdenv.isMips) ''

     

       89
       89
       +
             '' + optionalString (stdenv.isAarch32 || stdenv.isMips) ''

     

       90
       90
        
               configureFlagsArray=(-Dldflags="-lm -lrt")

     

       91
       91
        
             '' + optionalString stdenv.isDarwin ''

     

       92
       92
        
               substituteInPlace hints/darwin.sh --replace "env MACOSX_DEPLOYMENT_TARGET=10.3" ""

+1 -1

pkgs/development/interpreters/picolisp/default.nix

···

       9
       9
        
           sha256 = "1k3x6mvk9b34iiyml142bzh3gf241f25ywjlaagbxzb9vklpws75";

     

       10
       10
        
         };

     

       11
       11
        
         buildInputs = optional stdenv.is64bit jdk;

     

       12
       12
       -
         patchPhase = optionalString stdenv.isArm ''

     

       12
       12
       +
         patchPhase = optionalString stdenv.isAarch32 ''

     

       13
       13
        
           sed -i s/-m32//g Makefile

     

       14
       14
        
           cat >>Makefile <<EOF

     

       15
       15
        
           ext.o: ext.c

+4 -4

pkgs/development/interpreters/spidermonkey/1.8.5.nix

···

       11
       11
        
       

     

       12
       12
        
         propagatedBuildInputs = [ nspr ];

     

       13
       13
        
       

     

       14
       14
       -
         nativeBuildInputs = [ pkgconfig ] ++ lib.optional stdenv.isArm autoconf213;

     

       14
       14
       +
         nativeBuildInputs = [ pkgconfig ] ++ lib.optional stdenv.isAarch32 autoconf213;

     

       15
       15
        
         buildInputs = [ perl python2 zip ];

     

       16
       16
        
       

     

       17
       17
        
         postUnpack = "sourceRoot=\${sourceRoot}/js/src";

     
···

       19
       19
        
         preConfigure = ''

     

       20
       20
        
           export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -I${nspr.dev}/include/nspr"

     

       21
       21
        
           export LIBXUL_DIST=$out

     

       22
       22
       -
           ${lib.optionalString stdenv.isArm "autoreconf --verbose --force"}

     

       22
       22
       +
           ${lib.optionalString stdenv.isAarch32 "autoreconf --verbose --force"}

     

       23
       23
        
         '';

     

       24
       24
        
       

     

       25
       25
        
         patches = [

     
···

       28
       28
        
             url = "https://anonscm.debian.org/cgit/collab-maint/mozjs.git/plain/debian/patches/fix-811665.patch?id=00b15c7841968ab4f7fec409a6b93fa5e1e1d32e";

     

       29
       29
        
             sha256 = "1q8477xqxiy5d8376k5902l45gd0qkd4nxmhl8vr6rr1pxfcny99";

     

       30
       30
        
           })

     

       31
       31
       -
         ] ++ stdenv.lib.optionals stdenv.isArm [

     

       31
       31
       +
         ] ++ stdenv.lib.optionals stdenv.isAarch32 [

     

       32
       32
        
           # Explained below in configureFlags for ARM

     

       33
       33
        
           ./1.8.5-findvanilla.patch

     

       34
       34
        
           # Fix for hard float flags.

     
···

       50
       50
        
         # hack around a make problem, see https://github.com/NixOS/nixpkgs/issues/1279#issuecomment-29547393

     

       51
       51
        
         preBuild = ''

     

       52
       52
        
           touch -- {.,shell,jsapi-tests}/{-lpthread,-ldl}

     

       53
       53
       -
           ${if stdenv.isArm then "rm -r jit-test/tests/jaeger/bug563000" else ""}

     

       53
       53
       +
           ${if stdenv.isAarch32 then "rm -r jit-test/tests/jaeger/bug563000" else ""}

     

       54
       54
        
         '';

     

       55
       55
        
       

     

       56
       56
        
         enableParallelBuilding = true;

+7 -7

pkgs/development/libraries/ffmpeg/generic.nix

···

       7
       7
        
       # Build options

     

       8
       8
        
       , runtimeCpuDetectBuild ? true # Detect CPU capabilities at runtime

     

       9
       9
        
       , multithreadBuild ? true # Multithreading via pthreads/win32 threads

     

       10
       10
       -
       , sdlSupport ? !stdenv.isArm, SDL ? null, SDL2 ? null

     

       11
       11
       -
       , vdpauSupport ? !stdenv.isArm, libvdpau ? null

     

       10
       10
       +
       , sdlSupport ? !stdenv.isAarch32, SDL ? null, SDL2 ? null

     

       11
       11
       +
       , vdpauSupport ? !stdenv.isAarch32, libvdpau ? null

     

       12
       12
        
       # Developer options

     

       13
       13
        
       , debugDeveloper ? false

     

       14
       14
        
       , optimizationsDeveloper ? true

     
···

       42
       42
        
        */

     

       43
       43
        
       

     

       44
       44
        
       let

     

       45
       45
       -
         inherit (stdenv) icCygwin isDarwin isFreeBSD isLinux isArm;

     

       45
       45
       +
         inherit (stdenv) icCygwin isDarwin isFreeBSD isLinux isAarch32;

     

       46
       46
        
         inherit (stdenv.lib) optional optionals enableFeature;

     

       47
       47
        
       

     

       48
       48
        
         cmpVer = builtins.compareVersions;

     
···

       55
       55
        
         verFix = withoutFix: fixVer: withFix: if reqMatch fixVer then withFix else withoutFix;

     

       56
       56
        
       

     

       57
       57
        
         # Disable dependency that needs fixes before it will work on Darwin or Arm

     

       58
       58
       -
         disDarwinOrArmFix = origArg: minVer: fixArg: if ((isDarwin || isArm) && reqMin minVer) then fixArg else origArg;

     

       58
       58
       +
         disDarwinOrArmFix = origArg: minVer: fixArg: if ((isDarwin || isAarch32) && reqMin minVer) then fixArg else origArg;

     

       59
       59
        
       

     

       60
       60
       -
         vaapiSupport = reqMin "0.6" && ((isLinux || isFreeBSD) && !isArm);

     

       60
       60
       +
         vaapiSupport = reqMin "0.6" && ((isLinux || isFreeBSD) && !isAarch32);

     

       61
       61
        
       in

     

       62
       62
        
       

     

       63
       63
        
       assert openglSupport -> libGLU_combined != null;

     
···

       153
       153
        
           bzip2 fontconfig freetype gnutls libiconv lame libass libogg libtheora

     

       154
       154
        
           libvdpau libvorbis lzma soxr x264 x265 xvidcore zlib libopus

     

       155
       155
        
         ] ++ optional openglSupport libGLU_combined

     

       156
       156
       -
           ++ optionals (!isDarwin && !isArm) [ libvpx libpulseaudio ] # Need to be fixed on Darwin and ARM

     

       157
       157
       -
           ++ optional ((isLinux || isFreeBSD) && !isArm) libva

     

       156
       156
       +
           ++ optionals (!isDarwin && !isAarch32) [ libvpx libpulseaudio ] # Need to be fixed on Darwin and ARM

     

       157
       157
       +
           ++ optional ((isLinux || isFreeBSD) && !isAarch32) libva

     

       158
       158
        
           ++ optional isLinux alsaLib

     

       159
       159
        
           ++ optionals isDarwin darwinFrameworks

     

       160
       160
        
           ++ optional vdpauSupport libvdpau

+1 -1

pkgs/development/libraries/freetype/default.nix

···

       52
       52
        
         configureFlags = [ "--disable-static" "--bindir=$(dev)/bin" ];

     

       53
       53
        
       

     

       54
       54
        
         # The asm for armel is written with the 'asm' keyword.

     

       55
       55
       -
         CFLAGS = optionalString stdenv.isArm "-std=gnu99";

     

       55
       55
       +
         CFLAGS = optionalString stdenv.isAarch32 "-std=gnu99";

     

       56
       56
        
       

     

       57
       57
        
         enableParallelBuilding = true;

     

       58
       58

+1 -1

pkgs/development/libraries/glibc/common.nix

···

       127
       127
        
             (if cross ? float && cross.float == "soft" then "--without-fp" else "--with-fp")

     

       128
       128
        
           ] ++ lib.optionals (cross != null) [

     

       129
       129
        
             "--with-__thread"

     

       130
       130
       -
           ] ++ lib.optionals (cross == null && stdenv.isArm) [

     

       130
       130
       +
           ] ++ lib.optionals (cross == null && stdenv.isAarch32) [

     

       131
       131
        
             "--host=arm-linux-gnueabi"

     

       132
       132
        
             "--build=arm-linux-gnueabi"

     

       133
       133

+1 -1

pkgs/development/libraries/gmp/5.1.x.nix

···

       37
       37
        
         # The config.guess in GMP tries to runtime-detect various

     

       38
       38
        
         # ARM optimization flags via /proc/cpuinfo (and is also

     

       39
       39
        
         # broken on multicore CPUs). Avoid this impurity.

     

       40
       40
       -
         preConfigure = optionalString stdenv.isArm ''

     

       40
       40
       +
         preConfigure = optionalString stdenv.isAarch32 ''

     

       41
       41
        
             configureFlagsArray+=("--build=$(./configfsf.guess)")

     

       42
       42
        
           '';

     

       43
       43

+1 -1

pkgs/development/libraries/gmp/6.x.nix

···

       38
       38
        
         # The config.guess in GMP tries to runtime-detect various

     

       39
       39
        
         # ARM optimization flags via /proc/cpuinfo (and is also

     

       40
       40
        
         # broken on multicore CPUs). Avoid this impurity.

     

       41
       41
       -
         preConfigure = optionalString stdenv.isArm ''

     

       41
       41
       +
         preConfigure = optionalString stdenv.isAarch32 ''

     

       42
       42
        
             configureFlagsArray+=("--build=$(./configfsf.guess)")

     

       43
       43
        
           '';

     

       44
       44

+1 -1

pkgs/development/libraries/gnu-efi/default.nix

···

       21
       21
        
           "AR=${stdenv.cc.targetPrefix}ar"

     

       22
       22
        
           "RANLIB=${stdenv.cc.targetPrefix}ranlib"

     

       23
       23
        
           "OBJCOPY=${stdenv.cc.targetPrefix}objcopy"

     

       24
       24
       -
         ] ++ stdenv.lib.optional stdenv.isArm "ARCH=arm"

     

       24
       24
       +
         ] ++ stdenv.lib.optional stdenv.isAarch32 "ARCH=arm"

     

       25
       25
        
           ++ stdenv.lib.optional stdenv.isAarch64 "ARCH=aarch64";

     

       26
       26
        
       

     

       27
       27
        
         meta = with stdenv.lib; {

+1 -1

pkgs/development/libraries/icu/base.nix

···

       31
       31
        
       

     

       32
       32
        
             # $(includedir) is different from $(prefix)/include due to multiple outputs

     

       33
       33
        
             sed -i -e 's|^\(CPPFLAGS = .*\) -I\$(prefix)/include|\1 -I$(includedir)|' config/Makefile.inc.in

     

       34
       34
       -
           '' + stdenv.lib.optionalString stdenv.isArm ''

     

       34
       34
       +
           '' + stdenv.lib.optionalString stdenv.isAarch32 ''

     

       35
       35
        
             # From https://archlinuxarm.org/packages/armv7h/icu/files/icudata-stdlibs.patch

     

       36
       36
        
             sed -e 's/LDFLAGSICUDT=-nodefaultlibs -nostdlib/LDFLAGSICUDT=/' -i config/mh-linux

     

       37
       37
        
           '';

+1 -1

pkgs/development/libraries/jemalloc/common.nix

···

       16
       16
        
                          # jemalloc is unable to correctly detect transparent hugepage support on

     

       17
       17
        
                          # ARM (https://github.com/jemalloc/jemalloc/issues/526), and the default

     

       18
       18
        
                          # kernel ARMv6/7 kernel does not enable it, so we explicitly disable support

     

       19
       19
       -
                          ++ stdenv.lib.optional stdenv.isArm "--disable-thp";

     

       19
       19
       +
                          ++ stdenv.lib.optional stdenv.isAarch32 "--disable-thp";

     

       20
       20
        
         doCheck = true;

     

       21
       21
        
       

     

       22
       22
        
         enableParallelBuilding = true;

+1 -1

pkgs/development/libraries/libdrm/default.nix

···

       20
       20
        
           "echo : \\\${ac_cv_func_clock_gettime=\'yes\'} > config.cache";

     

       21
       21
        
       

     

       22
       22
        
         configureFlags = [ "--enable-install-test-programs" ]

     

       23
       23
       -
           ++ stdenv.lib.optionals (stdenv.isArm || stdenv.isAarch64)

     

       23
       23
       +
           ++ stdenv.lib.optionals (stdenv.isAarch32 || stdenv.isAarch64)

     

       24
       24
        
             [ "--enable-tegra-experimental-api" "--enable-etnaviv-experimental-api" ]

     

       25
       25
        
           ++ stdenv.lib.optional stdenv.isDarwin "-C";

     

       26
       26

+1 -1

pkgs/development/libraries/libtoxcore/default.nix

···

       20
       20
        
       

     

       21
       21
        
         buildInputs = [

     

       22
       22
        
           libsodium libmsgpack ncurses libconfig

     

       23
       23
       -
         ] ++ stdenv.lib.optionals (!stdenv.isArm) [

     

       23
       23
       +
         ] ++ stdenv.lib.optionals (!stdenv.isAarch32) [

     

       24
       24
        
           libopus

     

       25
       25
        
           libvpx

     

       26
       26
        
         ];

+2 -2

pkgs/development/libraries/libtoxcore/new-api.nix

···

       33
       33
        
         nativeBuildInputs = [ autoreconfHook pkgconfig ];

     

       34
       34
        
         buildInputs = [

     

       35
       35
        
           autoreconfHook libsodium ncurses check libconfig

     

       36
       36
       -
         ] ++ stdenv.lib.optionals (!stdenv.isArm) [

     

       36
       36
       +
         ] ++ stdenv.lib.optionals (!stdenv.isAarch32) [

     

       37
       37
        
           libopus

     

       38
       38
        
         ];

     

       39
       39
        
       

     

       40
       40
       -
         propagatedBuildInputs = stdenv.lib.optionals (!stdenv.isArm) [ libvpx ];

     

       40
       40
       +
         propagatedBuildInputs = stdenv.lib.optionals (!stdenv.isAarch32) [ libvpx ];

     

       41
       41
        
       

     

       42
       42
        
         # Some tests fail randomly due to timeout. This kind of problem is well known

     

       43
       43
        
         # by upstream: https://github.com/irungentoo/toxcore/issues/{950,1054}

+1 -1

pkgs/development/libraries/libvpx/default.nix

···

       41
       41
        
       }:

     

       42
       42
        
       

     

       43
       43
        
       let

     

       44
       44
       -
         inherit (stdenv) isi686 isx86_64 isArm is64bit isMips isDarwin isCygwin;

     

       44
       44
       +
         inherit (stdenv) isi686 isx86_64 isAarch32 is64bit isMips isDarwin isCygwin;

     

       45
       45
        
         inherit (stdenv.lib) enableFeature optional optionals;

     

       46
       46
        
       in

     

       47
       47

+2 -2

pkgs/development/libraries/libvpx/git.nix

···

       43
       43
        
       }:

     

       44
       44
        
       

     

       45
       45
        
       let

     

       46
       46
       -
         inherit (stdenv) isi686 isx86_64 isArm is64bit isMips isDarwin isCygwin;

     

       46
       46
       +
         inherit (stdenv) isi686 isx86_64 isAarch32 is64bit isMips isDarwin isCygwin;

     

       47
       47
        
         inherit (stdenv.lib) enableFeature optional optionals;

     

       48
       48
        
       in

     

       49
       49
        
       

     

       50
       50
       -
       assert isi686 || isx86_64 || isArm || isMips; # Requires ARM with floating point support

     

       50
       50
       +
       assert isi686 || isx86_64 || isAarch32 || isMips; # Requires ARM with floating point support

     

       51
       51
        
       

     

       52
       52
        
       assert vp8DecoderSupport || vp8EncoderSupport || vp9DecoderSupport || vp9EncoderSupport;

     

       53
       53
        
       assert internalStatsSupport && (vp9DecoderSupport || vp9EncoderSupport) -> postprocSupport;

+3 -3

pkgs/development/libraries/mesa/default.nix

···

       33
       33
        
       

     

       34
       34
        
       let

     

       35
       35
        
         defaultGalliumDrivers =

     

       36
       36
       -
           if stdenv.isArm

     

       36
       36
       +
           if stdenv.isAarch32

     

       37
       37
        
           then ["nouveau" "freedreno" "vc4" "etnaviv" "imx"]

     

       38
       38
        
           else if stdenv.isAarch64

     

       39
       39
        
           then ["nouveau" "vc4" ]

     

       40
       40
        
           else ["svga" "i915" "r300" "r600" "radeonsi" "nouveau"];

     

       41
       41
        
         defaultDriDrivers =

     

       42
       42
       -
           if (stdenv.isArm || stdenv.isAarch64)

     

       42
       42
       +
           if (stdenv.isAarch32 || stdenv.isAarch64)

     

       43
       43
        
           then ["nouveau"]

     

       44
       44
        
           else ["i915" "i965" "nouveau" "radeon" "r200"];

     

       45
       45
        
         defaultVulkanDrivers =

     

       46
       46
       -
           if (stdenv.isArm || stdenv.isAarch64)

     

       46
       46
       +
           if (stdenv.isAarch32 || stdenv.isAarch64)

     

       47
       47
        
           then []

     

       48
       48
        
           else ["intel"] ++ lib.optional enableRadv "radeon";

     

       49
       49
        
       in

+1 -1

pkgs/development/libraries/pixman/default.nix

···

       22
       22
        
       

     

       23
       23
        
         buildInputs = stdenv.lib.optional doCheck libpng;

     

       24
       24
        
       

     

       25
       25
       -
         configureFlags = stdenv.lib.optional stdenv.isArm "--disable-arm-iwmmxt";

     

       25
       25
       +
         configureFlags = stdenv.lib.optional stdenv.isAarch32 "--disable-arm-iwmmxt";

     

       26
       26
        
       

     

       27
       27
        
         doCheck = true;

     

       28
       28

+1 -1

pkgs/development/libraries/pth/default.nix

···

       8
       8
        
           sha256 = "0ckjqw5kz5m30srqi87idj7xhpw6bpki43mj07bazjm2qmh3cdbj";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
       -
         preConfigure = stdenv.lib.optionalString stdenv.isArm ''

     

       11
       11
       +
         preConfigure = stdenv.lib.optionalString stdenv.isAarch32 ''

     

       12
       12
        
           configureFlagsArray=("CFLAGS=-DJB_SP=8 -DJB_PC=9")

     

       13
       13
        
         '';

     

       14
       14

+2 -2

pkgs/development/libraries/v8/3.16.14.nix

···

       3
       3
        
       assert readline != null;

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
       -
         arch = if stdenv.isArm

     

       6
       6
       +
         arch = if stdenv.isAarch32

     

       7
       7
        
           then (if stdenv.is64bit then "arm64" else "arm")

     

       8
       8
        
           else (if stdenv.is64bit then "x64" else "ia32");

     

       9
       9
       -
         armHardFloat = stdenv.isArm && (stdenv.platform.gcc.float or null) == "hard";

     

       9
       9
       +
         armHardFloat = stdenv.isAarch32 && (stdenv.platform.gcc.float or null) == "hard";

     

       10
       10
        
       in

     

       11
       11
        
       

     

       12
       12
        
       stdenv.mkDerivation rec {

+1 -1

pkgs/development/libraries/v8/6_x.nix

···

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
       -
         arch = if stdenv.isArm

     

       7
       7
       +
         arch = if stdenv.isAarch32

     

       8
       8
        
                then if stdenv.is64bit

     

       9
       9
        
                     then"arm64"

     

       10
       10
        
                     else "arm"

+1 -1

pkgs/development/libraries/v8/default.nix

···

       10
       10
        
         arch = if stdenv.isx86_64 then "x64"

     

       11
       11
        
                   else if stdenv.isi686 then "ia32"

     

       12
       12
        
                   else if stdenv.isAarch64 then "arm64"

     

       13
       13
       -
                   else if stdenv.isArm then "arm"

     

       13
       13
       +
                   else if stdenv.isAarch32 then "arm"

     

       14
       14
        
                   else throw "Unknown architecture for v8";

     

       15
       15
        
         git_url = "https://chromium.googlesource.com";

     

       16
       16
        
         clangFlag = if stdenv.isDarwin then "1" else "0";

+1 -1

pkgs/development/libraries/webrtc-audio-processing/default.nix

···

       10
       10
        
       

     

       11
       11
        
         # Avoid this error:

     

       12
       12
        
         # signal_processing/filter_ar_fast_q12_armv7.S:88: Error: selected processor does not support `sbfx r11,r6,#12,#16' in ARM mode

     

       13
       13
       -
         patchPhase = stdenv.lib.optionalString stdenv.isArm ''

     

       13
       13
       +
         patchPhase = stdenv.lib.optionalString stdenv.isAarch32 ''

     

       14
       14
        
           substituteInPlace configure --replace 'armv7*|armv8*' 'disabled'

     

       15
       15
        
         '' + stdenv.lib.optionalString stdenv.hostPlatform.isMusl ''

     

       16
       16
        
           substituteInPlace webrtc/base/checks.cc --replace 'defined(__UCLIBC__)' 1

+1 -1

pkgs/development/tools/misc/binutils/default.nix

···

       100
       100
        
         # TODO(@Ericson2314): Always pass "--target" and always targetPrefix.

     

       101
       101
        
         configurePlatforms =

     

       102
       102
        
           # TODO(@Ericson2314): Figure out what's going wrong with Arm

     

       103
       103
       -
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isArm

     

       103
       103
       +
           if buildPlatform == hostPlatform && hostPlatform == targetPlatform && targetPlatform.isAarch32

     

       104
       104
        
           then []

     

       105
       105
        
           else [ "build" "host" ] ++ stdenv.lib.optional (targetPlatform != hostPlatform) "target";

     

       106
       106

+2 -2

pkgs/development/tools/misc/uhd/default.nix

···

       38
       38
        
         # /nix/store/wd6r25miqbk9ia53pp669gn4wrg9n9cj-gcc-7.3.0/include/c++/7.3.0/bits/vector.tcc:394:7: note: parameter passing for argument of type 'std::vector<uhd::range_t>::iterator {aka __gnu_cxx::__normal_iterator<uhd::range_t*, std::vector<uhd::range_t> >}' changed in GCC 7.1

     

       39
       39
        
       

     

       40
       40
        
         cmakeFlags = [ "-DLIBUSB_INCLUDE_DIRS=${libusb1.dev}/include/libusb-1.0"] ++

     

       41
       41
       -
                      [ (stdenv.lib.optionalString stdenv.isArm "-DCMAKE_CXX_FLAGS=-Wno-psabi") ];

     

       41
       41
       +
                      [ (stdenv.lib.optionalString stdenv.isAarch32 "-DCMAKE_CXX_FLAGS=-Wno-psabi") ];

     

       42
       42
        
       

     

       43
       43
        
         nativeBuildInputs = [ cmake pkgconfig ];

     

       44
       44
        
         buildInputs = [ python pythonPackages.pyramid_mako orc libusb1 boost ];

     

       45
       45
        
       

     

       46
       46
        
         # Build only the host software

     

       47
       47
        
         preConfigure = "cd host";

     

       48
       48
       -
         patches = if stdenv.isArm then ./neon.patch else null;

     

       48
       48
       +
         patches = if stdenv.isAarch32 then ./neon.patch else null;

     

       49
       49
        
       

     

       50
       50
        
         postPhases = [ "installFirmware" ];

     

       51
       51

+1 -1

pkgs/os-specific/darwin/apple-source-releases/system_cmds/default.nix

···

       11
       11
        
                         apple_sdk.frameworks.IOKit openbsm ];

     

       12
       12
        
         # NIX_CFLAGS_COMPILE = lib.optionalString hostPlatform.isi686 "-D__i386__"

     

       13
       13
        
         #                    + lib.optionalString hostPlatform.isx86_64 "-D__x86_64__"

     

       14
       14
       -
         #                    + lib.optionalString hostPlatform.isArm "-D__arm__";

     

       14
       14
       +
         #                    + lib.optionalString hostPlatform.isAarch32 "-D__arm__";

     

       15
       15
        
         NIX_CFLAGS_COMPILE = [ "-DDAEMON_UID=1"

     

       16
       16
        
                                "-DDAEMON_GID=1"

     

       17
       17
        
                                "-DDEFAULT_AT_QUEUE=\'a\'"

+1 -1

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

···

       32
       32
        
       

     

       33
       33
        
             # We get a warning in armv5tel-linux and the fuloong2f, so we

     

       34
       34
        
             # disable -Werror in it.

     

       35
       35
       -
             ${stdenv.lib.optionalString (stdenv.isArm || stdenv.hostPlatform.isMips) ''

     

       35
       35
       +
             ${stdenv.lib.optionalString (stdenv.isAarch32 || stdenv.hostPlatform.isMips) ''

     

       36
       36
        
               sed -i s/-Werror// src/Makefile.am

     

       37
       37
        
             ''}

     

       38
       38
        
           '';

+1 -1

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

···

       355
       355
        
         SECURITY_SELINUX_BOOTPARAM_VALUE 0 # Disable SELinux by default

     

       356
       356
        
         SECURITY_YAMA? y # Prevent processes from ptracing non-children processes

     

       357
       357
        
         DEVKMEM n # Disable /dev/kmem

     

       358
       358
       -
         ${optionalString (! stdenv.hostPlatform.isArm)

     

       358
       358
       +
         ${optionalString (! stdenv.hostPlatform.isAarch32)

     

       359
       359
        
           (if versionOlder version "3.14" then ''

     

       360
       360
        
               CC_STACKPROTECTOR? y # Detect buffer overflows on the stack

     

       361
       361
        
             '' else ''

+1 -1

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

···

       79
       79
        
           "-Dsystem-gid-max=499"

     

       80
       80
        
           # "-Dtime-epoch=1"

     

       81
       81
        
       

     

       82
       82
       -
           (if stdenv.isArm || stdenv.isAarch64 || !hostPlatform.isEfi then "-Dgnu-efi=false" else "-Dgnu-efi=true")

     

       82
       82
       +
           (if stdenv.isAarch32 || stdenv.isAarch64 || !hostPlatform.isEfi then "-Dgnu-efi=false" else "-Dgnu-efi=true")

     

       83
       83
        
           "-Defi-libdir=${toString gnu-efi}/lib"

     

       84
       84
        
           "-Defi-includedir=${toString gnu-efi}/include/efi"

     

       85
       85
        
           "-Defi-ldsdir=${toString gnu-efi}/lib"

+1 -1

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

···

       43
       43
        
           UCLIBC_SUSV4_LEGACY y

     

       44
       44
        
           UCLIBC_HAS_THREADS_NATIVE y

     

       45
       45
        
           KERNEL_HEADERS "${linuxHeaders}/include"

     

       46
       46
       -
         '' + stdenv.lib.optionalString (stdenv.isArm && cross == null) ''

     

       46
       46
       +
         '' + stdenv.lib.optionalString (stdenv.isAarch32 && cross == null) ''

     

       47
       47
        
           CONFIG_ARM_EABI y

     

       48
       48
        
           ARCH_WANTS_BIG_ENDIAN n

     

       49
       49
        
           ARCH_BIG_ENDIAN n

+1 -1

pkgs/servers/sql/mariadb/default.nix

···

       123
       123
        
         buildInputs = common.buildInputs ++ [

     

       124
       124
        
           xz lzo lz4 bzip2 snappy

     

       125
       125
        
           libxml2 boost judy libevent cracklib

     

       126
       126
       -
         ] ++ optional (stdenv.isLinux && !stdenv.isArm) numactl;

     

       126
       126
       +
         ] ++ optional (stdenv.isLinux && !stdenv.isAarch32) numactl;

     

       127
       127
        
       

     

       128
       128
        
         cmakeFlags = common.cmakeFlags ++ [

     

       129
       129
        
           "-DMYSQL_DATADIR=/var/lib/mysql"

+1 -1

pkgs/stdenv/generic/default.nix

···

       117
       117
        
             # Utility flags to test the type of platform.

     

       118
       118
        
             inherit (hostPlatform)

     

       119
       119
        
               isDarwin isLinux isSunOS isHurd isCygwin isFreeBSD isOpenBSD

     

       120
       120
       -
               isi686 isx86_64 is64bit isArm isAarch64 isMips isBigEndian;

     

       120
       120
       +
               isi686 isx86_64 is64bit isAarch32 isAarch64 isMips isBigEndian;

     

       121
       121
        
       

     

       122
       122
        
             # Whether we should run paxctl to pax-mark binaries.

     

       123
       123
        
             needsPax = isLinux;

+1 -1

pkgs/tools/networking/cjdns/default.nix

···

       16
       16
        
           stdenv.lib.optional stdenv.isLinux utillinux;

     

       17
       17
        
       

     

       18
       18
        
         buildPhase =

     

       19
       19
       -
           stdenv.lib.optionalString stdenv.isArm "Seccomp_NO=1 "

     

       19
       19
       +
           stdenv.lib.optionalString stdenv.isAarch32 "Seccomp_NO=1 "

     

       20
       20
        
           + "bash do";

     

       21
       21
        
         installPhase = ''

     

       22
       22
        
           install -Dt "$out/bin/" cjdroute makekeys privatetopublic publictoip6

+1 -1

pkgs/tools/networking/filegive/default.nix

···

       1
       1
        
       { stdenv, fetchurl, fetchgit, go }:

     

       2
       2
        
       

     

       3
       3
       -
       assert stdenv.isLinux && (stdenv.isi686 || stdenv.isx86_64 || stdenv.isArm);

     

       3
       3
       +
       assert stdenv.isLinux && (stdenv.isi686 || stdenv.isx86_64 || stdenv.isAarch32);

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6

+1 -1

pkgs/tools/system/storebrowse/default.nix

···

       1
       1
        
       { stdenv, fetchurl, fetchhg, go, sqlite}:

     

       2
       2
        
       

     

       3
       3
       -
       assert stdenv.isLinux && (stdenv.isi686 || stdenv.isx86_64 || stdenv.isArm);

     

       3
       3
       +
       assert stdenv.isLinux && (stdenv.isi686 || stdenv.isx86_64 || stdenv.isAarch32);

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         name = "storebrowse-20130318212204";

+7 -7

pkgs/top-level/all-packages.nix

···

       6471
       6471
        
       

     

       6472
       6472
        
         openjdk = openjdk8;

     

       6473
       6473
        
       

     

       6474
       6474
       -
         jdk8 = if stdenv.isArm || stdenv.isAarch64 then oraclejdk8 else openjdk8 // { outputs = [ "out" ]; };

     

       6475
       6475
       -
         jre8 = if stdenv.isArm || stdenv.isAarch64 then oraclejre8 else lib.setName "openjre-${lib.getVersion pkgs.openjdk8.jre}"

     

       6474
       6474
       +
         jdk8 = if stdenv.isAarch32 || stdenv.isAarch64 then oraclejdk8 else openjdk8 // { outputs = [ "out" ]; };

     

       6475
       6475
       +
         jre8 = if stdenv.isAarch32 || stdenv.isAarch64 then oraclejre8 else lib.setName "openjre-${lib.getVersion pkgs.openjdk8.jre}"

     

       6476
       6476
        
           (lib.addMetaAttrs { outputsToInstall = [ "jre" ]; }

     

       6477
       6477
        
             (openjdk8.jre // { outputs = [ "jre" ]; }));

     

       6478
       6478
        
         jre8_headless =

     

       6479
       6479
       -
           if stdenv.isArm || stdenv.isAarch64 then

     

       6479
       6479
       +
           if stdenv.isAarch32 || stdenv.isAarch64 then

     

       6480
       6480
        
             oraclejre8

     

       6481
       6481
        
           else if stdenv.isDarwin then

     

       6482
       6482
        
             jre8

     
···

       6485
       6485
        
               (lib.addMetaAttrs { outputsToInstall = [ "jre" ]; }

     

       6486
       6486
        
                 ((openjdk8.override { minimal = true; }).jre // { outputs = [ "jre" ]; }));

     

       6487
       6487
        
       

     

       6488
       6488
       -
         jdk10 = if stdenv.isArm || stdenv.isAarch64 then oraclejdk10 else openjdk10 // { outputs = [ "out" ]; };

     

       6489
       6489
       -
         jre10 = if stdenv.isArm || stdenv.isAarch64 then oraclejre10 else lib.setName "openjre-${lib.getVersion pkgs.openjdk10.jre}"

     

       6488
       6488
       +
         jdk10 = if stdenv.isAarch32 || stdenv.isAarch64 then oraclejdk10 else openjdk10 // { outputs = [ "out" ]; };

     

       6489
       6489
       +
         jre10 = if stdenv.isAarch32 || stdenv.isAarch64 then oraclejre10 else lib.setName "openjre-${lib.getVersion pkgs.openjdk10.jre}"

     

       6490
       6490
        
           (lib.addMetaAttrs { outputsToInstall = [ "jre" ]; }

     

       6491
       6491
        
             (openjdk10.jre // { outputs = [ "jre" ]; }));

     

       6492
       6492
        
         jre10_headless =

     

       6493
       6493
       -
           if stdenv.isArm || stdenv.isAarch64 then

     

       6493
       6493
       +
           if stdenv.isAarch32 || stdenv.isAarch64 then

     

       6494
       6494
        
             oraclejre10

     

       6495
       6495
        
           else if stdenv.isDarwin then

     

       6496
       6496
        
             jre10

     
···

       9247
       9247
        
       

     

       9248
       9248
        
         cairo = callPackage ../development/libraries/cairo {

     

       9249
       9249
        
           glSupport = config.cairo.gl or (stdenv.isLinux &&

     

       9250
       9250
       -
             !stdenv.isArm && !stdenv.isMips);

     

       9250
       9250
       +
             !stdenv.isAarch32 && !stdenv.isMips);

     

       9251
       9251
        
         };

     

       9252
       9252
        
       

     

       9253
       9253