{
lib,
config,
}: let
lib' = config.lib;
types = config.lib.systems.types;
setTypes = type: let
assign = name: value:
assert lib.errors.trace (type.check value) "${name} is not of type ${type.name}: ${lib.generators.pretty {} value}";
lib.types.set type.name ({inherit name;} // value);
in
builtins.mapAttrs assign;
matchAnyAttrs = patterns:
if builtins.isList patterns
then value: builtins.any (pattern: lib.attrs.match pattern value) patterns
else lib.attrs.match patterns;
getDoubles = predicate:
builtins.map
lib'.systems.into.double
(builtins.filter predicate lib'.systems.doubles.all);
in {
config = {
lib.systems = {
match = builtins.mapAttrs (lib.fp.const matchAnyAttrs) lib'.systems.patterns;
platforms = {
pc = {
linux-kernel = {
name = "pc";
baseConfig = "defconfig";
# Build whatever possible as a module, if not stated in the extra config.
autoModules = true;
target = "bzImage";
};
};
pc_simplekernel = lib.attrs.mergeRecursive lib'.systems.platforms.pc {
linux-kernel.autoModules = false;
};
powernv = {
linux-kernel = {
name = "PowerNV";
baseConfig = "powernv_defconfig";
target = "vmlinux";
autoModules = true;
# avoid driver/FS trouble arising from unusual page size
extraConfig = ''
PPC_64K_PAGES n
PPC_4K_PAGES y
IPV6 y
ATA_BMDMA y
ATA_SFF y
VIRTIO_MENU y
'';
};
};
##
## ARM
##
pogoplug4 = {
linux-kernel = {
name = "pogoplug4";
baseConfig = "multi_v5_defconfig";
autoModules = false;
extraConfig = ''
# Ubi for the mtd
MTD_UBI y
UBIFS_FS y
UBIFS_FS_XATTR y
UBIFS_FS_ADVANCED_COMPR y
UBIFS_FS_LZO y
UBIFS_FS_ZLIB y
UBIFS_FS_DEBUG n
'';
makeFlags = ["LOADADDR=0x8000"];
target = "uImage";
# TODO reenable once manual-config's config actually builds a .dtb and this is checked to be working
#DTB = true;
};
gcc = {
arch = "armv5te";
};
};
sheevaplug = {
linux-kernel = {
name = "sheevaplug";
baseConfig = "multi_v5_defconfig";
autoModules = false;
extraConfig = ''
BLK_DEV_RAM y
BLK_DEV_INITRD y
BLK_DEV_CRYPTOLOOP m
BLK_DEV_DM m
DM_CRYPT m
MD y
REISERFS_FS m
BTRFS_FS m
XFS_FS m
JFS_FS m
EXT4_FS m
USB_STORAGE_CYPRESS_ATACB m
# mv cesa requires this sw fallback, for mv-sha1
CRYPTO_SHA1 y
# Fast crypto
CRYPTO_TWOFISH y
CRYPTO_TWOFISH_COMMON y
CRYPTO_BLOWFISH y
CRYPTO_BLOWFISH_COMMON y
IP_PNP y
IP_PNP_DHCP y
NFS_FS y
ROOT_NFS y
TUN m
NFS_V4 y
NFS_V4_1 y
NFS_FSCACHE y
NFSD m
NFSD_V2_ACL y
NFSD_V3 y
NFSD_V3_ACL y
NFSD_V4 y
NETFILTER y
IP_NF_IPTABLES y
IP_NF_FILTER y
IP_NF_MATCH_ADDRTYPE y
IP_NF_TARGET_LOG y
IP_NF_MANGLE y
IPV6 m
VLAN_8021Q m
CIFS y
CIFS_XATTR y
CIFS_POSIX y
CIFS_FSCACHE y
CIFS_ACL y
WATCHDOG y
WATCHDOG_CORE y
ORION_WATCHDOG m
ZRAM m
NETCONSOLE m
# Disable OABI to have seccomp_filter (required for systemd)
# https://github.com/raspberrypi/firmware/issues/651
OABI_COMPAT n
# Fail to build
DRM n
SCSI_ADVANSYS n
USB_ISP1362_HCD n
SND_SOC n
SND_ALI5451 n
FB_SAVAGE n
SCSI_NSP32 n
ATA_SFF n
SUNGEM n
IRDA n
ATM_HE n
SCSI_ACARD n
BLK_DEV_CMD640_ENHANCED n
FUSE_FS m
# systemd uses cgroups
CGROUPS y
# Latencytop
LATENCYTOP y
# Ubi for the mtd
MTD_UBI y
UBIFS_FS y
UBIFS_FS_XATTR y
UBIFS_FS_ADVANCED_COMPR y
UBIFS_FS_LZO y
UBIFS_FS_ZLIB y
UBIFS_FS_DEBUG n
# Kdb, for kernel troubles
KGDB y
KGDB_SERIAL_CONSOLE y
KGDB_KDB y
'';
makeFlags = ["LOADADDR=0x0200000"];
target = "uImage";
DTB = true; # Beyond 3.10
};
gcc = {
arch = "armv5te";
};
};
raspberrypi = {
linux-kernel = {
name = "raspberrypi";
baseConfig = "bcm2835_defconfig";
DTB = true;
autoModules = true;
preferBuiltin = true;
extraConfig = ''
# Disable OABI to have seccomp_filter (required for systemd)
# https://github.com/raspberrypi/firmware/issues/651
OABI_COMPAT n
'';
target = "zImage";
};
gcc = {
arch = "armv6";
fpu = "vfp";
};
};
# Legacy attribute, for compatibility with existing configs only.
raspberrypi2 = lib'.systems.platforms.armv7l-hf-multiplatform;
# Nvidia Bluefield 2 (w. crypto support)
bluefield2 = {
gcc = {
arch = "armv8-a+fp+simd+crc+crypto";
};
};
zero-gravitas = {
linux-kernel = {
name = "zero-gravitas";
baseConfig = "zero-gravitas_defconfig";
# Target verified by checking /boot on reMarkable 1 device
target = "zImage";
autoModules = false;
DTB = true;
};
gcc = {
fpu = "neon";
cpu = "cortex-a9";
};
};
zero-sugar = {
linux-kernel = {
name = "zero-sugar";
baseConfig = "zero-sugar_defconfig";
DTB = true;
autoModules = false;
preferBuiltin = true;
target = "zImage";
};
gcc = {
cpu = "cortex-a7";
fpu = "neon-vfpv4";
float-abi = "hard";
};
};
utilite = {
linux-kernel = {
name = "utilite";
maseConfig = "multi_v7_defconfig";
autoModules = false;
extraConfig = ''
# Ubi for the mtd
MTD_UBI y
UBIFS_FS y
UBIFS_FS_XATTR y
UBIFS_FS_ADVANCED_COMPR y
UBIFS_FS_LZO y
UBIFS_FS_ZLIB y
UBIFS_FS_DEBUG n
'';
makeFlags = ["LOADADDR=0x10800000"];
target = "uImage";
DTB = true;
};
gcc = {
cpu = "cortex-a9";
fpu = "neon";
};
};
guruplug = lib.recursiveUpdate lib'.systems.platforms.sheevaplug {
# Define `CONFIG_MACH_GURUPLUG' (see
# <http://kerneltrap.org/mailarchive/git-commits-head/2010/5/19/33618>)
# and other GuruPlug-specific things. Requires the `guruplug-defconfig'
# patch.
linux-kernel.baseConfig = "guruplug_defconfig";
};
beaglebone = lib.recursiveUpdate lib'.systems.platforms.armv7l-hf-multiplatform {
linux-kernel = {
name = "beaglebone";
baseConfig = "bb.org_defconfig";
autoModules = false;
extraConfig = ""; # TBD kernel config
target = "zImage";
};
};
# https://developer.android.com/ndk/guides/abis#v7a
armv7a-android = {
linux-kernel.name = "armeabi-v7a";
gcc = {
arch = "armv7-a";
float-abi = "softfp";
fpu = "vfpv3-d16";
};
};
armv7l-hf-multiplatform = {
linux-kernel = {
name = "armv7l-hf-multiplatform";
Major = "2.6"; # Using "2.6" enables 2.6 kernel syscalls in glibc.
baseConfig = "multi_v7_defconfig";
DTB = true;
autoModules = true;
preferBuiltin = true;
target = "zImage";
extraConfig = ''
# Serial port for Raspberry Pi 3. Wasn't included in ARMv7 defconfig
# until 4.17.
SERIAL_8250_BCM2835AUX y
SERIAL_8250_EXTENDED y
SERIAL_8250_SHARE_IRQ y
# Hangs ODROID-XU4
ARM_BIG_LITTLE_CPUIDLE n
# Disable OABI to have seccomp_filter (required for systemd)
# https://github.com/raspberrypi/firmware/issues/651
OABI_COMPAT n
# >=5.12 fails with:
# drivers/net/ethernet/micrel/ks8851_common.o: in function `ks8851_probe_common':
# ks8851_common.c:(.text+0x179c): undefined reference to `__this_module'
# See: https://lore.kernel.org/netdev/20210116164828.40545-1-marex@denx.de/T/
KS8851_MLL y
'';
};
gcc = {
# Some table about fpu flags:
# http://community.arm.com/servlet/JiveServlet/showImage/38-1981-3827/blogentry-103749-004812900+1365712953_thumb.png
# Cortex-A5: -mfpu=neon-fp16
# Cortex-A7 (rpi2): -mfpu=neon-vfpv4
# Cortex-A8 (beaglebone): -mfpu=neon
# Cortex-A9: -mfpu=neon-fp16
# Cortex-A15: -mfpu=neon-vfpv4
# More about FPU:
# https://wiki.debian.org/ArmHardFloatPort/VfpComparison
# vfpv3-d16 is what Debian uses and seems to be the best compromise: NEON is not supported in e.g. Scaleway or Tegra 2,
# and the above page suggests NEON is only an improvement with hand-written assembly.
arch = "armv7-a";
fpu = "vfpv3-d16";
# For Raspberry Pi the 2 the best would be:
# cpu = "cortex-a7";
# fpu = "neon-vfpv4";
};
};
aarch64-multiplatform = {
linux-kernel = {
name = "aarch64-multiplatform";
baseConfig = "defconfig";
DTB = true;
autoModules = true;
preferBuiltin = true;
extraConfig = ''
# Raspberry Pi 3 stuff. Not needed for s >= 4.10.
ARCH_BCM2835 y
BCM2835_MBOX y
BCM2835_WDT y
RASPBERRYPI_FIRMWARE y
RASPBERRYPI_POWER y
SERIAL_8250_BCM2835AUX y
SERIAL_8250_EXTENDED y
SERIAL_8250_SHARE_IRQ y
# Cavium ThunderX stuff.
PCI_HOST_THUNDER_ECAM y
# Nvidia Tegra stuff.
PCI_TEGRA y
# The default (=y) forces us to have the XHCI firmware available in initrd,
# which our initrd builder can't currently do easily.
USB_XHCI_TEGRA m
'';
target = "Image";
};
gcc = {
arch = "armv8-a";
};
};
apple-m1 = {
gcc = {
arch = "armv8.3-a+crypto+sha2+aes+crc+fp16+lse+simd+ras+rdm+rcpc";
cpu = "apple-a13";
};
};
##
## MIPS
##
ben_nanonote = {
linux-kernel = {
name = "ben_nanonote";
};
gcc = {
arch = "mips32";
float = "soft";
};
};
fuloong2f_n32 = {
linux-kernel = {
name = "fuloong2f_n32";
baseConfig = "lemote2f_defconfig";
autoModules = false;
extraConfig = ''
MIGRATION n
COMPACTION n
# nixos mounts some cgroup
CGROUPS y
BLK_DEV_RAM y
BLK_DEV_INITRD y
BLK_DEV_CRYPTOLOOP m
BLK_DEV_DM m
DM_CRYPT m
MD y
REISERFS_FS m
EXT4_FS m
USB_STORAGE_CYPRESS_ATACB m
IP_PNP y
IP_PNP_DHCP y
IP_PNP_BOOTP y
NFS_FS y
ROOT_NFS y
TUN m
NFS_V4 y
NFS_V4_1 y
NFS_FSCACHE y
NFSD m
NFSD_V2_ACL y
NFSD_V3 y
NFSD_V3_ACL y
NFSD_V4 y
# Fail to build
DRM n
SCSI_ADVANSYS n
USB_ISP1362_HCD n
SND_SOC n
SND_ALI5451 n
FB_SAVAGE n
SCSI_NSP32 n
ATA_SFF n
SUNGEM n
IRDA n
ATM_HE n
SCSI_ACARD n
BLK_DEV_CMD640_ENHANCED n
FUSE_FS m
# Needed for udev >= 150
SYSFS_DEPRECATED_V2 n
VGA_CONSOLE n
VT_HW_CONSOLE_BINDING y
SERIAL_8250_CONSOLE y
FRAMEBUFFER_CONSOLE y
EXT2_FS y
EXT3_FS y
REISERFS_FS y
MAGIC_SYSRQ y
# The kernel doesn't boot at all, with FTRACE
FTRACE n
'';
target = "vmlinux";
};
gcc = {
arch = "loongson2f";
float = "hard";
abi = "n32";
};
};
# can execute on 32bit chip
gcc_mips32r2_o32 = {
gcc = {
arch = "mips32r2";
abi = "32";
};
};
gcc_mips32r6_o32 = {
gcc = {
arch = "mips32r6";
abi = "32";
};
};
gcc_mips64r2_n32 = {
gcc = {
arch = "mips64r2";
abi = "n32";
};
};
gcc_mips64r6_n32 = {
gcc = {
arch = "mips64r6";
abi = "n32";
};
};
gcc_mips64r2_64 = {
gcc = {
arch = "mips64r2";
abi = "64";
};
};
gcc_mips64r6_64 = {
gcc = {
arch = "mips64r6";
abi = "64";
};
};
# based on:
# https://www.mail-archive.com/qemu-discuss@nongnu.org/msg05179.html
# https://gmplib.org/~tege/qemu.html#mips64-debian
mips64el-qemu-linux-gnuabi64 = {
linux-kernel = {
name = "mips64el";
baseConfig = "64r2el_defconfig";
target = "vmlinuz";
autoModules = false;
DTB = true;
# for qemu 9p passthrough filesystem
extraConfig = ''
MIPS_MALTA y
PAGE_SIZE_4KB y
CPU_LITTLE_ENDIAN y
CPU_MIPS64_R2 y
64BIT y
CPU_MIPS64_R2 y
NET_9P y
NET_9P_VIRTIO y
9P_FS y
9P_FS_POSIX_ACL y
PCI y
VIRTIO_PCI y
'';
};
};
##
## Other
##
riscv-multiplatform = {
linux-kernel = {
name = "riscv-multiplatform";
target = "Image";
autoModules = true;
baseConfig = "defconfig";
DTB = true;
extraConfig = ''
SERIAL_OF_PLATFORM y
'';
};
};
mipsel-linux-gnu =
{
triple = "mipsel-unknown-linux-gnu";
}
// lib'.systems.platforms.gcc_mips32r2_o32;
# This function takes a minimally-valid "platform" and returns an
# attrset containing zero or more additional attrs which should be
# included in the platform in order to further elaborate it.
select = platform:
# x86
/**/
if platform.isx86
then lib'.systems.platforms.pc
# ARM
else if platform.isAarch32
then let
version = platform.system.cpu.version or null;
in
if version == null
then lib'.systems.platforms.pc
else if lib.versions.gte "6" version
then lib'.systems.platforms.sheevaplug
else if lib.versions.gte "7" version
then lib'.systems.platforms.raspberrypi
else lib'.systems.platforms.armv7l-hf-multiplatform
else if platform.isAarch64
then
if platform.isDarwin
then lib'.systems.platforms.apple-m1
else lib'.systems.platforms.aarch64-multiplatform
else if platform.isRiscV
then lib'.systems.platforms.riscv-multiplatform
else if platform.system.cpu == types.cpus.mipsel
then lib'.systems.platforms.mipsel-linux-gnu
else if platform.system.cpu == types.cpus.powerpc64le
then lib'.systems.platforms.powernv
else {};
};
architectures = {
features = {
# x86_64 Generic
# Spec: https://gitlab.com/x86-psABIs/x86-64-ABI/
default = [];
x86-64 = [];
x86-64-v2 = ["sse3" "ssse3" "sse4_1" "sse4_2"];
x86-64-v3 = ["sse3" "ssse3" "sse4_1" "sse4_2" "avx" "avx2" "fma"];
x86-64-v4 = ["sse3" "ssse3" "sse4_1" "sse4_2" "avx" "avx2" "avx512" "fma"];
# x86_64 Intel
nehalem = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes"];
westmere = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes"];
sandybridge = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx"];
ivybridge = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx"];
haswell = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "fma"];
broadwell = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "fma"];
skylake = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "fma"];
skylake-avx512 = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "avx512" "fma"];
cannonlake = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "avx512" "fma"];
icelake-client = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "avx512" "fma"];
icelake-server = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "avx512" "fma"];
cascadelake = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "avx512" "fma"];
cooperlake = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "avx512" "fma"];
tigerlake = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "avx512" "fma"];
alderlake = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx" "avx2" "fma"];
# x86_64 AMD
btver1 = ["sse3" "ssse3" "sse4_1" "sse4_2"];
btver2 = ["sse3" "ssse3" "sse4_1" "sse4_2" "aes" "avx"];
bdver1 = ["sse3" "ssse3" "sse4_1" "sse4_2" "sse4a" "aes" "avx" "fma" "fma4"];
bdver2 = ["sse3" "ssse3" "sse4_1" "sse4_2" "sse4a" "aes" "avx" "fma" "fma4"];
bdver3 = ["sse3" "ssse3" "sse4_1" "sse4_2" "sse4a" "aes" "avx" "fma" "fma4"];
bdver4 = ["sse3" "ssse3" "sse4_1" "sse4_2" "sse4a" "aes" "avx" "avx2" "fma" "fma4"];
znver1 = ["sse3" "ssse3" "sse4_1" "sse4_2" "sse4a" "aes" "avx" "avx2" "fma"];
znver2 = ["sse3" "ssse3" "sse4_1" "sse4_2" "sse4a" "aes" "avx" "avx2" "fma"];
znver3 = ["sse3" "ssse3" "sse4_1" "sse4_2" "sse4a" "aes" "avx" "avx2" "fma"];
znver4 = ["sse3" "ssse3" "sse4_1" "sse4_2" "sse4a" "aes" "avx" "avx2" "avx512" "fma"];
# other
armv5te = [];
armv6 = [];
armv7-a = [];
armv8-a = [];
mips32 = [];
loongson2f = [];
};
# a superior CPU has all the features of an inferior and is able to build and test code for it
inferiors = {
# x86_64 Generic
default = [];
x86-64 = [];
x86-64-v2 = ["x86-64"];
x86-64-v3 = ["x86-64-v2"] ++ lib'.systems.architectures.inferiors.x86-64-v2;
x86-64-v4 = ["x86-64-v3"] ++ lib'.systems.architectures.inferiors.x86-64-v3;
# x86_64 Intel
# https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html
nehalem = ["x86-64-v2"] ++ lib'.systems.architectures.inferiors.x86-64-v2;
westmere = ["nehalem"] ++ lib'.systems.architectures.inferiors.nehalem;
sandybridge = ["westmere"] ++ lib'.systems.architectures.inferiors.westmere;
ivybridge = ["sandybridge"] ++ lib'.systems.architectures.inferiors.sandybridge;
haswell = lib.unique (["ivybridge" "x86-64-v3"] ++ lib'.systems.architectures.inferiors.ivybridge ++ lib'.systems.architectures.inferiors.x86-64-v3);
broadwell = ["haswell"] ++ lib'.systems.architectures.inferiors.haswell;
skylake = ["broadwell"] ++ lib'.systems.architectures.inferiors.broadwell;
skylake-avx512 = lib.unique (["skylake" "x86-64-v4"] ++ lib'.systems.architectures.inferiors.skylake ++ lib'.systems.architectures.inferiors.x86-64-v4);
cannonlake = ["skylake-avx512"] ++ lib'.systems.architectures.inferiors.skylake-avx512;
icelake-client = ["cannonlake"] ++ lib'.systems.architectures.inferiors.cannonlake;
icelake-server = ["icelake-client"] ++ lib'.systems.architectures.inferiors.icelake-client;
cascadelake = ["cannonlake"] ++ lib'.systems.architectures.inferiors.cannonlake;
cooperlake = ["cascadelake"] ++ lib'.systems.architectures.inferiors.cascadelake;
tigerlake = ["icelake-server"] ++ lib'.systems.architectures.inferiors.icelake-server;
# CX16 does not exist on alderlake, while it does on nearly all other intel CPUs
alderlake = [];
# x86_64 AMD
# TODO: fill this (need testing)
btver1 = [];
btver2 = [];
bdver1 = [];
bdver2 = [];
bdver3 = [];
bdver4 = [];
# Regarding `skylake` as inferior of `znver1`, there are reports of
# successful usage by Gentoo users and Phoronix benchmarking of different
# `-march` targets.
#
# The GCC documentation on extensions used and wikichip documentation
# regarding supperted extensions on znver1 and skylake was used to create
# this partial order.
#
# Note:
#
# - The successors of `skylake` (`cannonlake`, `icelake`, etc) use `avx512`
# which no current AMD Zen michroarch support.
# - `znver1` uses `ABM`, `CLZERO`, `CX16`, `MWAITX`, and `SSE4A` which no
# current Intel microarch support.
#
# https://www.phoronix.com/scan.php?page=article&item=amd-znver3-gcc11&num=1
# https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html
# https://en.wikichip.org/wiki/amd/microarchitectures/zen
# https://en.wikichip.org/wiki/intel/microarchitectures/skylake
znver1 = ["skylake"] ++ lib'.systems.architectures.inferiors.skylake; # Includes haswell and x86-64-v3
znver2 = ["znver1"] ++ lib'.systems.architectures.inferiors.znver1;
znver3 = ["znver2"] ++ lib'.systems.architectures.inferiors.znver2;
znver4 = lib.unique (["znver3" "x86-64-v4"] ++ lib'.systems.architectures.inferiors.znver3 ++ lib'.systems.architectures.inferiors.x86-64-v4);
# other
armv5te = [];
armv6 = [];
armv7-a = [];
armv8-a = [];
mips32 = [];
loongson2f = [];
};
};
validate = {
architecture = let
isSupported = feature: x:
builtins.elem feature (lib'.systems.architectures.features.${x} or []);
in {
sse3Support = isSupported "sse3";
ssse3Support = isSupported "ssse3";
sse4_1Support = isSupported "sse4_1";
sse4_2Support = isSupported "sse4_2";
sse4_aSupport = isSupported "sse4a";
avxSupport = isSupported "avx";
avx2Support = isSupported "avx2";
avx512Support = isSupported "avx512";
aesSupport = isSupported "aes";
fmaSupport = isSupported "fma";
fma4Support = isSupported "fma4";
};
compatible = a: b:
lib.any lib.id [
# x86
(b == lib'.systems.types.cpus.i386 && lib'.systems.validate.compatible a lib'.systems.types.cpus.i486)
(b == lib'.systems.types.cpus.i486 && lib'.systems.validate.compatible a lib'.systems.types.cpus.i586)
(b == lib'.systems.types.cpus.i586 && lib'.systems.validate.compatible a lib'.systems.types.cpus.i686)
# XXX: Not true in some cases. Like in WSL mode.
(b == lib'.systems.types.cpus.i686 && lib'.systems.validate.compatible a lib'.systems.types.cpus.x86_64)
# ARMv4
(b == lib'.systems.types.cpus.arm && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv5tel)
# ARMv5
(b == lib'.systems.types.cpus.armv5tel && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv6l)
# ARMv6
(b == lib'.systems.types.cpus.armv6l && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv6m)
(b == lib'.systems.types.cpus.armv6m && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv7l)
# ARMv7
(b == lib'.systems.types.cpus.armv7l && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv7a)
(b == lib'.systems.types.cpus.armv7l && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv7r)
(b == lib'.systems.types.cpus.armv7l && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv7m)
# ARMv8
(b == lib'.systems.types.cpus.aarch64 && a == lib'.systems.types.cpus.armv8a)
(b == lib'.systems.types.cpus.armv8a && lib'.systems.validate.compatible a lib'.systems.types.cpus.aarch64)
(b == lib'.systems.types.cpus.armv8r && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv8a)
(b == lib'.systems.types.cpus.armv8m && lib'.systems.validate.compatible a lib'.systems.types.cpus.armv8a)
# PowerPC
(b == lib'.systems.types.cpus.powerpc && lib'.systems.validate.compatible a lib'.systems.types.cpus.powerpc64)
(b == lib'.systems.types.cpus.powerpcle && lib'.systems.validate.compatible a lib'.systems.types.cpus.powerpc64le)
# MIPS
(b == lib'.systems.types.cpus.mips && lib'.systems.validate.compatible a lib'.systems.types.cpus.mips64)
(b == lib'.systems.types.cpus.mipsel && lib'.systems.validate.compatible a lib'.systems.types.cpus.mips64el)
# RISCV
(b == lib'.systems.types.cpus.riscv32 && lib'.systems.validate.compatible a lib'.systems.types.cpus.riscv64)
# SPARC
(b == lib'.systems.types.cpus.sparc && lib'.systems.validate.compatible a lib'.systems.types.cpus.sparc64)
# WASM
(b == lib'.systems.types.cpus.wasm32 && lib'.systems.validate.compatible a lib'.systems.types.cpus.wasm64)
# identity
(b == a)
];
};
types = {
generic = {
endian = lib.types.create {
name = "Endian";
description = "Endianness";
merge = lib.options.merge.one;
};
cpu = lib.types.create {
name = "Cpu";
description = "Instruction set architecture name and information";
merge = lib.options.merge.one;
check = x:
types.bits.check x.bits
&& (
if 8 < x.bits
then types.endian.check x.endian
else !(x ? endian)
);
};
family = lib.types.create {
name = "Family";
description = "The kernel family.";
merge = lib.options.merge.one;
};
exec = lib.types.create {
name = "Exec";
description = "Executable container used by the kernel";
merge = lib.options.merge.one;
};
kernel = lib.types.create {
name = "Kernel";
description = "Kernel name and information";
merge = lib.options.merge.one;
check = value:
types.exec.check value.exec
&& builtins.all types.family.check (builtins.attrValues value.families);
};
abi = lib.types.create {
name = "Abi";
description = "Binary interface for compiled code and syscalls";
merge = lib.options.merge.one;
};
vendor = lib.types.create {
name = "Vendor";
description = "Vendor for the platform";
merge = lib.options.merge.one;
};
};
platform = lib.types.create {
name = "system";
description = "fully parsed representation of llvm- or nix-style platform tuple";
merge = lib.options.merge.one;
check = {
cpu,
vendor,
kernel,
abi,
}:
types.cpu.check cpu
&& types.vendor.check vendor
&& types.kernel.check kernel
&& types.abi.check abi;
};
endian = lib.types.enum (builtins.attrValues types.endians);
endians = setTypes types.generic.endian {
big = {};
little = {};
};
bits = lib.types.enum [8 16 32 64 128];
exec = lib.types.enum (builtins.attrValues types.execs);
execs = setTypes types.generic.exec {
aout = {}; # a.out
elf = {};
macho = {};
pe = {};
wasm = {};
unknown = {};
};
vendor = lib.types.enum (builtins.attrValues types.vendors);
vendors = setTypes types.generic.vendor {
apple = {};
pc = {};
knuth = {};
# Actually matters, unlocking some MinGW-w64-specific options in GCC. See
# bottom of https://sourceforge.net/p/mingw-w64/wiki2/Unicode%20apps/
w64 = {};
none = {};
unknown = {};
};
family = lib.types.enum (builtins.attrValues types.families);
families = setTypes types.generic.family {
bsd = {};
darwin = {};
};
kernel = lib.types.enum (builtins.attrValues types.kernels);
kernels = setTypes types.generic.kernel {
# TODO(@Ericson2314): Don't want to mass-rebuild yet to keeping 'darwin' as
# the normalized name for macOS.
macos = {
exec = types.execs.macho;
families = {
darwin = types.families.darwin;
};
name = "darwin";
};
ios = {
exec = types.execs.macho;
families = {darwin = types.families.darwin;};
};
# A tricky thing about FreeBSD is that there is no stable ABI across
# versions. That means that putting in the version as part of the
# config string is paramount.
freebsd12 = {
exec = types.execs.elf;
families = {bsd = types.families.bsd;};
name = "freebsd";
version = 12;
};
freebsd13 = {
exec = types.execs.elf;
families = {bsd = types.families.bsd;};
name = "freebsd";
version = 13;
};
linux = {
exec = types.execs.elf;
families = {};
};
netbsd = {
exec = types.execs.elf;
families = {bsd = types.families.bsd;};
};
none = {
exec = types.execs.unknown;
families = {};
};
openbsd = {
exec = types.execs.elf;
families = {bsd = types.families.bsd;};
};
solaris = {
exec = types.execs.elf;
families = {};
};
wasi = {
exec = types.execs.wasm;
families = {};
};
redox = {
exec = types.execs.elf;
families = {};
};
windows = {
exec = types.execs.pe;
families = {};
};
ghcjs = {
exec = types.execs.unknown;
families = {};
};
genode = {
exec = types.execs.elf;
families = {};
};
mmixware = {
exec = types.execs.unknown;
families = {};
};
# aliases
# 'darwin' is the kernel for all of them. We choose macOS by default.
darwin = types.kernels.macos;
watchos = types.kernels.ios;
tvos = types.kernels.ios;
win32 = types.kernels.windows;
};
cpu = lib.types.enum (builtins.attrValues types.cpus);
cpus = setTypes types.generic.cpu {
arm = {
bits = 32;
endian = types.endians.little;
family = "arm";
};
armv5tel = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "5";
arch = "armv5t";
};
armv6m = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "6";
arch = "armv6-m";
};
armv6l = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "6";
arch = "armv6";
};
armv7a = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "7";
arch = "armv7-a";
};
armv7r = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "7";
arch = "armv7-r";
};
armv7m = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "7";
arch = "armv7-m";
};
armv7l = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "7";
arch = "armv7";
};
armv8a = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "8";
arch = "armv8-a";
};
armv8r = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "8";
arch = "armv8-a";
};
armv8m = {
bits = 32;
endian = types.endians.little;
family = "arm";
version = "8";
arch = "armv8-m";
};
aarch64 = {
bits = 64;
endian = types.endians.little;
family = "arm";
version = "8";
arch = "armv8-a";
};
aarch64_be = {
bits = 64;
endian = types.endians.big;
family = "arm";
version = "8";
arch = "armv8-a";
};
i386 = {
bits = 32;
endian = types.endians.little;
family = "x86";
arch = "i386";
};
i486 = {
bits = 32;
endian = types.endians.little;
family = "x86";
arch = "i486";
};
i586 = {
bits = 32;
endian = types.endians.little;
family = "x86";
arch = "i586";
};
i686 = {
bits = 32;
endian = types.endians.little;
family = "x86";
arch = "i686";
};
x86_64 = {
bits = 64;
endian = types.endians.little;
family = "x86";
arch = "x86-64";
};
microblaze = {
bits = 32;
endian = types.endians.big;
family = "microblaze";
};
microblazeel = {
bits = 32;
endian = types.endians.little;
family = "microblaze";
};
mips = {
bits = 32;
endian = types.endians.big;
family = "mips";
};
mipsel = {
bits = 32;
endian = types.endians.little;
family = "mips";
};
mips64 = {
bits = 64;
endian = types.endians.big;
family = "mips";
};
mips64el = {
bits = 64;
endian = types.endians.little;
family = "mips";
};
mmix = {
bits = 64;
endian = types.endians.big;
family = "mmix";
};
m68k = {
bits = 32;
endian = types.endians.big;
family = "m68k";
};
powerpc = {
bits = 32;
endian = types.endians.big;
family = "power";
};
powerpc64 = {
bits = 64;
endian = types.endians.big;
family = "power";
};
powerpc64le = {
bits = 64;
endian = types.endians.little;
family = "power";
};
powerpcle = {
bits = 32;
endian = types.endians.little;
family = "power";
};
riscv32 = {
bits = 32;
endian = types.endians.little;
family = "riscv";
};
riscv64 = {
bits = 64;
endian = types.endians.little;
family = "riscv";
};
s390 = {
bits = 32;
endian = types.endians.big;
family = "s390";
};
s390x = {
bits = 64;
endian = types.endians.big;
family = "s390";
};
sparc = {
bits = 32;
endian = types.endians.big;
family = "sparc";
};
sparc64 = {
bits = 64;
endian = types.endians.big;
family = "sparc";
};
wasm32 = {
bits = 32;
endian = types.endians.little;
family = "wasm";
};
wasm64 = {
bits = 64;
endian = types.endians.little;
family = "wasm";
};
alpha = {
bits = 64;
endian = types.endians.little;
family = "alpha";
};
rx = {
bits = 32;
endian = types.endians.little;
family = "rx";
};
msp430 = {
bits = 16;
endian = types.endians.little;
family = "msp430";
};
avr = {
bits = 8;
family = "avr";
};
vc4 = {
bits = 32;
endian = types.endians.little;
family = "vc4";
};
or1k = {
bits = 32;
endian = types.endians.big;
family = "or1k";
};
loongarch64 = {
bits = 64;
endian = types.endians.little;
family = "loongarch";
};
javascript = {
bits = 32;
endian = types.endians.little;
family = "javascript";
};
};
abi = lib.types.enum (builtins.attrValues types.abis);
abis = setTypes types.generic.abi {
cygnus = {};
msvc = {};
# Note: eabi is specific to ARM and PowerPC.
# On PowerPC, this corresponds to PPCEABI.
# On ARM, this corresponds to ARMEABI.
eabi = {float = "soft";};
eabihf = {float = "hard";};
# Other architectures should use ELF in embedded situations.
elf = {};
androideabi = {};
android = {
assertions = [
{
assertion = platform: !platform.isAarch32;
message = ''
The "android" ABI is not for 32-bit ARM. Use "androideabi" instead.
'';
}
];
};
gnueabi = {float = "soft";};
gnueabihf = {float = "hard";};
gnu = {
assertions = [
{
assertion = platform: !platform.isAarch32;
message = ''
The "gnu" ABI is ambiguous on 32-bit ARM. Use "gnueabi" or "gnueabihf" instead.
'';
}
{
assertion = platform: with platform; !(isPower64 && isBigEndian);
message = ''
The "gnu" ABI is ambiguous on big-endian 64-bit PowerPC. Use "gnuabielfv2" or "gnuabielfv1" instead.
'';
}
];
};
gnuabi64 = {abi = "64";};
muslabi64 = {abi = "64";};
# NOTE: abi=n32 requires a 64-bit MIPS chip! That is not a typo.
# It is basically the 64-bit abi with 32-bit pointers. Details:
# https://www.linux-mips.org/pub/linux/mips/doc/ABI/MIPS-N32-ABI-Handbook.pdf
gnuabin32 = {abi = "n32";};
muslabin32 = {abi = "n32";};
gnuabielfv2 = {abi = "elfv2";};
gnuabielfv1 = {abi = "elfv1";};
musleabi = {float = "soft";};
musleabihf = {float = "hard";};
musl = {};
uclibceabi = {float = "soft";};
uclibceabihf = {float = "hard";};
uclibc = {};
unknown = {};
};
};
from = {
string = value: let
parts = lib.strings.split "-" value;
skeleton = lib'.systems.skeleton parts;
system = lib'.systems.create (lib'.systems.from.skeleton skeleton);
in
system;
skeleton = spec @ {
cpu,
vendor ? assert false; null,
kernel,
abi ? assert false; null,
}: let
getCpu = name: types.cpus.${name} or (throw "Unknown CPU type: ${name}");
getVendor = name: types.vendors.${name} or (throw "Unknown vendor: ${name}");
getKernel = name: types.kernels.${name} or (throw "Unknown kernel: ${name}");
getAbi = name: types.abis.${name} or (throw "Unknown ABI: ${name}");
resolved = {
cpu = getCpu spec.cpu;
vendor =
if spec ? vendor
then getVendor spec.vendor
else if lib'.systems.match.isDarwin resolved
then types.vendors.apple
else if lib'.systems.match.isWindows resolved
then types.vendors.pc
else types.vendors.unknown;
kernel =
if lib.strings.hasPrefix "darwin" spec.kernel
then getKernel "darwin"
else if lib.strings.hasPrefix "netbsd" spec.kernel
then getKernel "netbsd"
else getKernel spec.kernel;
abi =
if spec ? abi
then getAbi spec.abi
else if lib'.systems.match.isLinux resolved || lib'.systems.match.isWindows resolved
then
if lib'.systems.match.isAarch32 resolved
then
if lib.versions.gte "6" (resolved.cpu.version)
then types.abis.gnueabihf
else types.abis.gnueabi
else if lib'.systems.match.isPower64 resolved && lib'.systems.match.isBigEndian resolved
then types.abis.gnuabielfv2
else types.abis.gnu
else types.abis.unknown;
};
in
resolved;
};
into = {
double = {
cpu,
kernel,
abi,
...
}: let
kernelName = kernel.name + builtins.toString (kernel.version or "");
in
if abi == types.abis.cygnus
then "${cpu.name}-cygwin"
else if kernel.families ? darwin
then "${cpu.name}-darwin"
else "${cpu.name}-${kernelName}";
triple = {
cpu,
vendor,
kernel,
abi,
...
}: let
kernelName = kernel.name + builtins.toString (kernel.version or "");
netbsdExec =
if
(cpu.family == "arm" && cpu.bits == 32)
|| (cpu.family == "sparc" && cpu.bits == 32)
|| (cpu.family == "m68k" && cpu.bits == 32)
|| (cpu.family == "x86" && cpu.bits == 32)
then types.execs.aout
else types.execs.elf;
exec =
lib.strings.when
(kernel.name == "netbsd" && netbsdExec != kernel.exec)
kernel.exec.name;
abi = lib.strings.when (abi != types.abis.unknown) "-${abi.name}";
in "${cpu.name}-${vendor.name}-${kernelName}${exec}${abi}";
};
create = components:
assert types.platform.check components;
lib.types.set "system" components;
skeleton = parts: let
length = builtins.length parts;
first = builtins.elemAt parts 0;
second = builtins.elemAt parts 1;
third = builtins.elemAt parts 2;
fourth = builtins.elemAt parts 3;
in
if length == 1
then
if first == "avr"
then {
cpu = first;
kernel = "none";
abi = "unknown";
}
else builtins.throw "Target specification with 1 component is ambiguous."
else if length == 2
then
if second == "cygwin"
then {
cpu = first;
kernel = "windows";
abi = "cygnus";
}
else if second == "windows"
then {
cpu = first;
kernel = "windows";
abi = "msvc";
}
else if second == "elf"
then {
cpu = first;
vendor = "unkonwn";
kernel = "none";
abi = second;
}
else {
cpu = first;
kernel = second;
}
else if length == 3
then
if second == "linux" || (builtins.elem third ["eabi" "eabihf" "elf" "gnu"])
then {
cpu = first;
vendor = "unknown";
kernel = second;
abi = third;
}
else if
(second == "apple")
|| lib.strings.hasPrefix "freebsd" third
|| lib.strings.hasPrefix "netbsd" third
|| lib.strings.hasPrefix "genode" third
|| (builtins.elem third ["wasi" "redox" "mmixware" "ghcjs" "mingw32"])
then {
cpu = first;
vendor = second;
kernel =
if third == "mingw32"
then "windows"
else third;
}
else builtins.throw "Target specification with 3 components is ambiguous."
else if length == 4
then {
cpu = first;
vendor = second;
kernel = third;
abi = fourth;
}
else builtins.throw "Invalid component count for creating system skeleton. Expected 1-4, but got ${builtins.toString length}.";
patterns = {
isi686 = {cpu = types.cpus.i686;};
isx86_32 = {
cpu = {
family = "x86";
bits = 32;
};
};
isx86_64 = {
cpu = {
family = "x86";
bits = 64;
};
};
isPower = {cpu = {family = "power";};};
isPower64 = {
cpu = {
family = "power";
bits = 64;
};
};
# This ABI is the default in NixOS PowerPC64 BE, but not on mainline GCC,
# so it sometimes causes issues in certain packages that makes the wrong
# assumption on the used ABI.
isAbiElfv2 = [
{abi = {abi = "elfv2";};}
{
abi = {name = "musl";};
cpu = {
family = "power";
bits = 64;
};
}
];
isx86 = {cpu = {family = "x86";};};
isAarch32 = {
cpu = {
family = "arm";
bits = 32;
};
};
isArmv7 =
map ({arch, ...}: {cpu = {inherit arch;};})
(lib.filter (cpu: lib.hasPrefix "armv7" cpu.arch or "")
(lib.attrValues types.cpus));
isAarch64 = {
cpu = {
family = "arm";
bits = 64;
};
};
isAarch = {cpu = {family = "arm";};};
isMicroBlaze = {cpu = {family = "microblaze";};};
isMips = {cpu = {family = "mips";};};
isMips32 = {
cpu = {
family = "mips";
bits = 32;
};
};
isMips64 = {
cpu = {
family = "mips";
bits = 64;
};
};
isMips64n32 = {
cpu = {
family = "mips";
bits = 64;
};
abi = {abi = "n32";};
};
isMips64n64 = {
cpu = {
family = "mips";
bits = 64;
};
abi = {abi = "64";};
};
isMmix = {cpu = {family = "mmix";};};
isRiscV = {cpu = {family = "riscv";};};
isRiscV32 = {
cpu = {
family = "riscv";
bits = 32;
};
};
isRiscV64 = {
cpu = {
family = "riscv";
bits = 64;
};
};
isRx = {cpu = {family = "rx";};};
isSparc = {cpu = {family = "sparc";};};
isWasm = {cpu = {family = "wasm";};};
isMsp430 = {cpu = {family = "msp430";};};
isVc4 = {cpu = {family = "vc4";};};
isAvr = {cpu = {family = "avr";};};
isAlpha = {cpu = {family = "alpha";};};
isOr1k = {cpu = {family = "or1k";};};
isM68k = {cpu = {family = "m68k";};};
isS390 = {cpu = {family = "s390";};};
isS390x = {
cpu = {
family = "s390";
bits = 64;
};
};
isLoongArch64 = {
cpu = {
family = "loongarch";
bits = 64;
};
};
isJavaScript = {cpu = types.cpus.javascript;};
is32bit = {cpu = {bits = 32;};};
is64bit = {cpu = {bits = 64;};};
isILP32 = builtins.map (a: {abi = {abi = a;};}) ["n32" "ilp32" "x32"];
isBigEndian = {cpu = {endian = types.endians.big;};};
isLittleEndian = {cpu = {endian = types.endians.little;};};
isBSD = {kernel = {families = {bsd = types.families.bsd;};};};
isDarwin = {kernel = {families = {darwin = types.families.darwin;};};};
isUnix = [lib'.systems.match.isBSD lib'.systems.match.isDarwin lib'.systems.match.isLinux lib'.systems.match.isSunOS lib'.systems.match.isCygwin lib'.systems.match.isRedox];
isMacOS = {kernel = types.kernels.macos;};
isiOS = {kernel = types.kernels.ios;};
isLinux = {kernel = types.kernels.linux;};
isSunOS = {kernel = types.kernels.solaris;};
isFreeBSD = {kernel = {name = "freebsd";};};
isNetBSD = {kernel = types.kernels.netbsd;};
isOpenBSD = {kernel = types.kernels.openbsd;};
isWindows = {kernel = types.kernels.windows;};
isCygwin = {
kernel = types.kernels.windows;
abi = types.abis.cygnus;
};
isMinGW = {
kernel = types.kernels.windows;
abi = types.abis.gnu;
};
isWasi = {kernel = types.kernels.wasi;};
isRedox = {kernel = types.kernels.redox;};
isGhcjs = {kernel = types.kernels.ghcjs;};
isGenode = {kernel = types.kernels.genode;};
isNone = {kernel = types.kernels.none;};
isAndroid = [{abi = types.abis.android;} {abi = types.abis.androideabi;}];
isGnu = builtins.map (value: {abi = value;}) [types.abis.gnuabi64 types.abis.gnuabin32 types.abis.gnu types.abis.gnueabi types.abis.gnueabihf types.abis.gnuabielfv1 types.abis.gnuabielfv2];
isMusl = builtins.map (value: {abi = value;}) [types.abis.musl types.abis.musleabi types.abis.musleabihf types.abis.muslabin32 types.abis.muslabi64];
isUClibc = builtins.map (value: {abi = value;}) [types.abis.uclibc types.abis.uclibceabi types.abis.uclibceabihf];
isEfi = [
{
cpu = {
family = "arm";
version = "6";
};
}
{
cpu = {
family = "arm";
version = "7";
};
}
{
cpu = {
family = "arm";
version = "8";
};
}
{cpu = {family = "riscv";};}
{cpu = {family = "x86";};}
];
};
doubles = {
resolved = builtins.map lib'.systems.from.string lib'.systems.doubles.all;
all = [
# Cygwin
"i686-cygwin"
"x86_64-cygwin"
# Darwin
"x86_64-darwin"
"i686-darwin"
"aarch64-darwin"
"armv7a-darwin"
# FreeBSD
"i686-freebsd13"
"x86_64-freebsd13"
# Genode
"aarch64-genode"
"i686-genode"
"x86_64-genode"
# illumos
"x86_64-solaris"
# JS
"javascript-ghcjs"
# Linux
"aarch64-linux"
"armv5tel-linux"
"armv6l-linux"
"armv7a-linux"
"armv7l-linux"
"i686-linux"
"loongarch64-linux"
"m68k-linux"
"microblaze-linux"
"microblazeel-linux"
"mips-linux"
"mips64-linux"
"mips64el-linux"
"mipsel-linux"
"powerpc64-linux"
"powerpc64le-linux"
"riscv32-linux"
"riscv64-linux"
"s390-linux"
"s390x-linux"
"x86_64-linux"
# MMIXware
"mmix-mmixware"
# NetBSD
"aarch64-netbsd"
"armv6l-netbsd"
"armv7a-netbsd"
"armv7l-netbsd"
"i686-netbsd"
"m68k-netbsd"
"mipsel-netbsd"
"powerpc-netbsd"
"riscv32-netbsd"
"riscv64-netbsd"
"x86_64-netbsd"
# none
"aarch64_be-none"
"aarch64-none"
"arm-none"
"armv6l-none"
"avr-none"
"i686-none"
"microblaze-none"
"microblazeel-none"
"mips-none"
"mips64-none"
"msp430-none"
"or1k-none"
"m68k-none"
"powerpc-none"
"powerpcle-none"
"riscv32-none"
"riscv64-none"
"rx-none"
"s390-none"
"s390x-none"
"vc4-none"
"x86_64-none"
# OpenBSD
"i686-openbsd"
"x86_64-openbsd"
# Redox
"x86_64-redox"
# WASI
"wasm64-wasi"
"wasm32-wasi"
# Windows
"x86_64-windows"
"i686-windows"
];
arm = getDoubles lib'.systems.match.isAarch32;
armv7 = getDoubles lib'.systems.match.isArmv7;
aarch64 = getDoubles lib'.systems.match.isAarch64;
x86 = getDoubles lib'.systems.match.isx86;
i686 = getDoubles lib'.systems.match.isi686;
x86_64 = getDoubles lib'.systems.match.isx86_64;
microblaze = getDoubles lib'.systems.match.isMicroBlaze;
mips = getDoubles lib'.systems.match.isMips;
mmix = getDoubles lib'.systems.match.isMmix;
power = getDoubles lib'.systems.match.isPower;
riscv = getDoubles lib'.systems.match.isRiscV;
riscv32 = getDoubles lib'.systems.match.isRiscV32;
riscv64 = getDoubles lib'.systems.match.isRiscV64;
rx = getDoubles lib'.systems.match.isRx;
vc4 = getDoubles lib'.systems.match.isVc4;
or1k = getDoubles lib'.systems.match.isOr1k;
m68k = getDoubles lib'.systems.match.isM68k;
s390 = getDoubles lib'.systems.match.isS390;
s390x = getDoubles lib'.systems.match.isS390x;
loongarch64 = getDoubles lib'.systems.match.isLoongArch64;
js = getDoubles lib'.systems.match.isJavaScript;
bigEndian = getDoubles lib'.systems.match.isBigEndian;
littleEndian = getDoubles lib'.systems.match.isLittleEndian;
cygwin = getDoubles lib'.systems.match.isCygwin;
darwin = getDoubles lib'.systems.match.isDarwin;
freebsd = getDoubles lib'.systems.match.isFreeBSD;
# Should be better, but MinGW is unclear.
gnu =
getDoubles (lib.attrs.match {
kernel = types.kernels.linux;
abi = types.abis.gnu;
})
++ getDoubles (lib.attrs.match {
kernel = types.kernels.linux;
abi = types.abis.gnueabi;
})
++ getDoubles (lib.attrs.match {
kernel = types.kernels.linux;
abi = types.abis.gnueabihf;
})
++ getDoubles (lib.attrs.match {
kernel = types.kernels.linux;
abi = types.abis.gnuabin32;
})
++ getDoubles (lib.attrs.match {
kernel = types.kernels.linux;
abi = types.abis.gnuabi64;
})
++ getDoubles (lib.attrs.match {
kernel = types.kernels.linux;
abi = types.abis.gnuabielfv1;
})
++ getDoubles (lib.attrs.match {
kernel = types.kernels.linux;
abi = types.abis.gnuabielfv2;
});
illumos = getDoubles lib'.systems.match.isSunOS;
linux = getDoubles lib'.systems.match.isLinux;
netbsd = getDoubles lib'.systems.match.isNetBSD;
openbsd = getDoubles lib'.systems.match.isOpenBSD;
unix = getDoubles lib'.systems.match.isUnix;
wasi = getDoubles lib'.systems.match.isWasi;
redox = getDoubles lib'.systems.match.isRedox;
windows = getDoubles lib'.systems.match.isWindows;
genode = getDoubles lib'.systems.match.isGenode;
embedded = getDoubles lib'.systems.match.isNone;
mesaPlatforms = ["i686-linux" "x86_64-linux" "x86_64-darwin" "armv5tel-linux" "armv6l-linux" "armv7l-linux" "armv7a-linux" "aarch64-linux" "powerpc64-linux" "powerpc64le-linux" "aarch64-darwin" "riscv64-linux"];
};
withBuildInfo = args: let
settings =
if builtins.isString args
then {system = args;}
else args;
matchers = builtins.mapAttrs (name: match: match resolved.system) lib'.systems.match;
validators = builtins.mapAttrs (name: validate: validate (resolved.gcc.arch or "default")) lib'.systems.match.architecture;
platformInfo =
{
linux-kernel = settings.linux-kernel or {};
gcc = settings.gcc or {};
rustc = settings.rustc or {};
}
// lib'.systems.platforms.select resolved;
resolved =
matchers
// validators
// platformInfo
// {
system = lib'.systems.from.string (
if settings ? triple
then settings.triple
else settings.system
);
double = lib'.systems.into.double resolved.system;
triple = lib'.systems.into.triple resolved.system;
isExecutable = platform:
(resolved.isAndroid == platform.isAndroid)
&& resolved.system.kernel == platform.system.kernel
&& lib'.systems.validate.compatible resolved.system.cpu platform.system.cpu;
# The difference between `isStatic` and `hasSharedLibraries` is mainly the
# addition of the `staticMarker` (see make-derivation.nix). Some
# platforms, like embedded machines without a libc (e.g. arm-none-eabi)
# don't support dynamic linking, but don't get the `staticMarker`.
# `pkgsStatic` sets `isStatic=true`, so `pkgsStatic.hostPlatform` always
# has the `staticMarker`.
isStatic = resolved.isWasm || resolved.isRedox;
# It is important that hasSharedLibraries==false when the platform has no
# dynamic library loader. Various tools (including the gcc build system)
# have knowledge of which platforms are incapable of dynamic linking, and
# will still build on/for those platforms with --enable-shared, but simply
# omit any `.so` build products such as libgcc_s.so. When that happens,
# it causes hard-to-troubleshoot build failures.
hasSharedLibraries =
!resolved.isStatic
&& (
# Linux (allows multiple libcs)
resolved.isAndroid
|| resolved.isGnu
|| resolved.isMusl
# BSDs
|| resolved.isDarwin
|| resolved.isSunOS
|| resolved.isOpenBSD
|| resolved.isFreeBSD
|| resolved.isNetBSD
# Windows
|| resolved.isCygwin
|| resolved.isMinGW
);
libc =
if resolved.isDarwin
then "libSystem"
else if resolved.isMinGW
then "msvcrt"
else if resolved.isWasi
then "wasilibc"
else if resolved.isRedox
then "relibc"
else if resolved.isMusl
then "musl"
else if resolved.isUClibc
then "uclibc"
else if resolved.isAndroid
then "bionic"
else if resolved.isLinux
then "glibc"
else if resolved.isFreeBSD
then "fblibc"
else if resolved.isNetBSD
then "nblibc"
else if resolved.isAvr
then "avrlibc"
else if resolved.isGhcjs
then null
else if resolved.isNone
then "newlib"
else "native/impure";
linker =
if resolved.isDarwin
then "cctools"
else "bfd";
extensions =
(lib.attrs.when resolved.hasSharedLibraries {
shared =
if resolved.isDarwin
then ".dylib"
else if resolved.isWindows
then ".dll"
else ".so";
})
// {
static =
if resolved.isWindows
then ".lib"
else ".a";
library =
if resolved.isStatic
then resolved.extensions.static
else resolved.extensions.shared;
executable =
if resolved.isWindows
then ".exe"
else "";
};
uname = {
system =
if resolved.system.kernel.name == "linux"
then "Linux"
else if resolved.system.kernel.name == "windows"
then "Windows"
else if resolved.system.kernel.name == "darwin"
then "Darwin"
else if resolved.system.kernel.name == "netbsd"
then "NetBSD"
else if resolved.system.kernel.name == "freebsd"
then "FreeBSD"
else if resolved.system.kernel.name == "openbsd"
then "OpenBSD"
else if resolved.system.kernel.name == "wasi"
then "Wasi"
else if resolved.system.kernel.name == "redox"
then "Redox"
else if resolved.system.kernel.name == "redox"
then "Genode"
else null;
processor =
if resolved.isPower64
then "ppc64${lib.strings.when resolved.isLittleEndian "le"}"
else if resolved.isPower
then "ppc${lib.strings.when resolved.isLittleEndian "le"}"
else if resolved.isMips64
then "mips64"
else resolved.system.cpu.name;
release = null;
};
useAndroidPrebuilt = false;
useiOSPrebuilt = false;
linux.arch =
if resolved.isAarch32
then "arm"
else if resolved.isAarch64
then "arm64"
else if resolved.isx86_32
then "i386"
else if resolved.isx86_64
then "x86_64"
# linux kernel does not distinguish microblaze/microblazeel
else if resolved.isMicroBlaze
then "microblaze"
else if resolved.isMips32
then "mips"
else if resolved.isMips64
then "mips" # linux kernel does not distinguish mips32/mips64
else if resolved.isPower
then "powerpc"
else if resolved.isRiscV
then "riscv"
else if resolved.isS390
then "s390"
else if resolved.isLoongArch64
then "loongarch"
else resolved.system.cpu.name;
uboot.arch =
if resolved.isx86_32
then "x86" # not i386
else if resolved.isMips64
then "mips64" # uboot *does* distinguish between mips32/mips64
else resolved.linuxArch; # other cases appear to agree with linuxArch
qemu.arch =
if resolved.isAarch32
then "arm"
else if resolved.isS390 && !resolved.isS390x
then null
else if resolved.isx86_64
then "x86_64"
else if resolved.isx86
then "i386"
else if resolved.isMips64n32
then "mipsn32${lib.strings.when resolved.isLittleEndian "el"}"
else if resolved.isMips64
then "mips64${lib.strings.when resolved.isLittleEndian "el"}"
else resolved.uname.processor;
efi.arch =
if resolved.isx86_32
then "ia32"
else if resolved.isx86_64
then "x64"
else if resolved.isAarch32
then "arm"
else if resolved.isAarch64
then "aa64"
else resolved.system.cpu.name;
darwin = {
arch =
if resolved.system.cpu.name == "armv7a"
then "armv7"
else if resolved.system.cpu.name == "aarch64"
then "arm64"
else resolved.system.cpu.name;
platform =
if resolved.isMacOS
then "macos"
else if resolved.isiOS
then "ios"
else null;
sdk = {
version =
resolved.darwinSdkVersion
or (
if resolved.isAarch64
then "11.0"
else "10.12"
);
min = resolved.darwin.sdk.version;
variable =
if resolved.isMacOS
then "MACOSX_DEPLOYMENT_TARGET"
else if resolved.isiOS
then "IPHONEOS_DEPLOYMENT_TARGET"
else null;
};
};
}
// settings;
assertions =
builtins.foldl'
(
result: {
assertion,
message,
}:
if assertion resolved
then result
else builtins.throw message
)
true
(resolved.system.abi.assertions or []);
in
assert resolved.useAndroidPrebuild -> resolved.isAndroid;
assert assertions;
# And finally, return the generated system info.
resolved;
};
};
}