Something went wrong. Try again.
What happens if I push all of nixpkgs
Something went wrong. Try again.
Nix
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964# Define the list of system with their properties.## See https://clang.llvm.org/docs/CrossCompilation.html and# http://llvm.org/docs/doxygen/html/Triple_8cpp_source.html especially# Triple::normalize. Parsing should essentially act as a more conservative# version of that last function.## Most of the types below come in "open" and "closed" pairs. The open ones# specify what information we need to know about systems in general, and the# closed ones are sub-types representing the whitelist of systems we support in# practice.## Code in the remainder of nixpkgs shouldn't rely on the closed ones in# e.g. exhaustive cases. Its more a sanity check to make sure nobody defines# systems that overlap with existing ones and won't notice something amiss.#{ lib }:
let inherit (lib) all any attrValues elem elemAt hasPrefix id length mapAttrs mergeOneOption optionalString splitString versionAtLeast ;
inherit (lib.strings) match;
inherit (lib.systems.inspect.predicates) isAarch32 isBigEndian isDarwin isLinux isPower64 isWindows ;
inherit (lib.types) enum float isType mkOptionType number setType string types ;
setTypes = type: mapAttrs ( name: value: assert type.check value; setType type.name ({ inherit name; } // value) );
# gnu-config will ignore the portion of a triple matching the # regex `e?abi.*$` when determining the validity of a triple. In # other words, `i386-linuxabichickenlips` is a valid triple. removeAbiSuffix = x: let found = match "(.*)e?abi.*" x; in if found == null then x else elemAt found 0;
in
rec {
################################################################################
types.openSignificantByte = mkOptionType { name = "significant-byte"; description = "Endianness"; merge = mergeOneOption; };
types.significantByte = enum (attrValues significantBytes);
significantBytes = setTypes types.openSignificantByte { bigEndian = { }; littleEndian = { }; };
################################################################################
# Reasonable power of 2 types.bitWidth = enum [ 8 16 32 64 128 ];
################################################################################
types.openCpuType = mkOptionType { name = "cpu-type"; description = "instruction set architecture name and information"; merge = mergeOneOption; check = x: types.bitWidth.check x.bits && (if 8 < x.bits then types.significantByte.check x.significantByte else !(x ? significantByte)); };
types.cpuType = enum (attrValues cpuTypes);
cpuTypes = let inherit (significantBytes) bigEndian littleEndian; in setTypes types.openCpuType { arm = { bits = 32; significantByte = littleEndian; family = "arm"; }; armv5tel = { bits = 32; significantByte = littleEndian; family = "arm"; version = "5"; arch = "armv5t"; }; armv6m = { bits = 32; significantByte = littleEndian; family = "arm"; version = "6"; arch = "armv6-m"; }; armv6l = { bits = 32; significantByte = littleEndian; family = "arm"; version = "6"; arch = "armv6"; }; armv7a = { bits = 32; significantByte = littleEndian; family = "arm"; version = "7"; arch = "armv7-a"; }; armv7r = { bits = 32; significantByte = littleEndian; family = "arm"; version = "7"; arch = "armv7-r"; }; armv7m = { bits = 32; significantByte = littleEndian; family = "arm"; version = "7"; arch = "armv7-m"; }; armv7l = { bits = 32; significantByte = littleEndian; family = "arm"; version = "7"; arch = "armv7"; }; armv8a = { bits = 32; significantByte = littleEndian; family = "arm"; version = "8"; arch = "armv8-a"; }; armv8r = { bits = 32; significantByte = littleEndian; family = "arm"; version = "8"; arch = "armv8-a"; }; armv8m = { bits = 32; significantByte = littleEndian; family = "arm"; version = "8"; arch = "armv8-m"; }; aarch64 = { bits = 64; significantByte = littleEndian; family = "arm"; version = "8"; arch = "armv8-a"; }; aarch64_be = { bits = 64; significantByte = bigEndian; family = "arm"; version = "8"; arch = "armv8-a"; };
i386 = { bits = 32; significantByte = littleEndian; family = "x86"; arch = "i386"; }; i486 = { bits = 32; significantByte = littleEndian; family = "x86"; arch = "i486"; }; i586 = { bits = 32; significantByte = littleEndian; family = "x86"; arch = "i586"; }; i686 = { bits = 32; significantByte = littleEndian; family = "x86"; arch = "i686"; }; x86_64 = { bits = 64; significantByte = littleEndian; family = "x86"; arch = "x86-64"; };
microblaze = { bits = 32; significantByte = bigEndian; family = "microblaze"; }; microblazeel = { bits = 32; significantByte = littleEndian; family = "microblaze"; };
mips = { bits = 32; significantByte = bigEndian; family = "mips"; }; mipsel = { bits = 32; significantByte = littleEndian; family = "mips"; }; mips64 = { bits = 64; significantByte = bigEndian; family = "mips"; }; mips64el = { bits = 64; significantByte = littleEndian; family = "mips"; };
mmix = { bits = 64; significantByte = bigEndian; family = "mmix"; };
m68k = { bits = 32; significantByte = bigEndian; family = "m68k"; };
powerpc = { bits = 32; significantByte = bigEndian; family = "power"; }; powerpc64 = { bits = 64; significantByte = bigEndian; family = "power"; }; powerpc64le = { bits = 64; significantByte = littleEndian; family = "power"; }; powerpcle = { bits = 32; significantByte = littleEndian; family = "power"; };
riscv32 = { bits = 32; significantByte = littleEndian; family = "riscv"; }; riscv64 = { bits = 64; significantByte = littleEndian; family = "riscv"; };
s390 = { bits = 32; significantByte = bigEndian; family = "s390"; }; s390x = { bits = 64; significantByte = bigEndian; family = "s390"; };
sparc = { bits = 32; significantByte = bigEndian; family = "sparc"; }; sparc64 = { bits = 64; significantByte = bigEndian; family = "sparc"; };
wasm32 = { bits = 32; significantByte = littleEndian; family = "wasm"; }; wasm64 = { bits = 64; significantByte = littleEndian; family = "wasm"; };
alpha = { bits = 64; significantByte = littleEndian; family = "alpha"; };
rx = { bits = 32; significantByte = littleEndian; family = "rx"; }; msp430 = { bits = 16; significantByte = littleEndian; family = "msp430"; }; avr = { bits = 8; family = "avr"; };
vc4 = { bits = 32; significantByte = littleEndian; family = "vc4"; };
or1k = { bits = 32; significantByte = bigEndian; family = "or1k"; };
loongarch64 = { bits = 64; significantByte = littleEndian; family = "loongarch"; };
javascript = { bits = 32; significantByte = littleEndian; family = "javascript"; }; } // { # aliases # Apple architecture name, as used by `darwinArch`; required by # LLVM ≥ 20. arm64 = cpuTypes.aarch64; };
# GNU build systems assume that older NetBSD architectures are using a.out. gnuNetBSDDefaultExecFormat = cpu: 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 execFormats.aout else execFormats.elf;
# Determine when two CPUs are compatible with each other. That is, # can code built for system B run on system A? For that to happen, # the programs that system B accepts must be a subset of the # programs that system A accepts. # # We have the following properties of the compatibility relation, # which must be preserved when adding compatibility information for # additional CPUs. # - (reflexivity) # Every CPU is compatible with itself. # - (transitivity) # If A is compatible with B and B is compatible with C then A is compatible with C. # # Note: Since 22.11 the archs of a mode switching CPU are no longer considered # pairwise compatible. Mode switching implies that binaries built for A # and B respectively can't be executed at the same time. isCompatible = with cpuTypes; a: b: any id [ # x86 (b == i386 && isCompatible a i486) (b == i486 && isCompatible a i586) (b == i586 && isCompatible a i686)
# XXX: Not true in some cases. Like in WSL mode. (b == i686 && isCompatible a x86_64)
# ARMv4 (b == arm && isCompatible a armv5tel)
# ARMv5 (b == armv5tel && isCompatible a armv6l)
# ARMv6 (b == armv6l && isCompatible a armv6m) (b == armv6m && isCompatible a armv7l)
# ARMv7 (b == armv7l && isCompatible a armv7a) (b == armv7l && isCompatible a armv7r) (b == armv7l && isCompatible a armv7m)
# ARMv8 (b == aarch64 && a == armv8a) (b == armv8a && isCompatible a aarch64) (b == armv8r && isCompatible a armv8a) (b == armv8m && isCompatible a armv8a)
# PowerPC (b == powerpc && isCompatible a powerpc64) (b == powerpcle && isCompatible a powerpc64le)
# MIPS (b == mips && isCompatible a mips64) (b == mipsel && isCompatible a mips64el)
# RISCV (b == riscv32 && isCompatible a riscv64)
# SPARC (b == sparc && isCompatible a sparc64)
# WASM (b == wasm32 && isCompatible a wasm64)
# identity (b == a) ];
################################################################################
types.openVendor = mkOptionType { name = "vendor"; description = "vendor for the platform"; merge = mergeOneOption; };
types.vendor = enum (attrValues vendors);
vendors = setTypes types.openVendor { 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 = { }; };
################################################################################
types.openExecFormat = mkOptionType { name = "exec-format"; description = "executable container used by the kernel"; merge = mergeOneOption; };
types.execFormat = enum (attrValues execFormats);
execFormats = setTypes types.openExecFormat { aout = { }; # a.out elf = { }; macho = { }; pe = { }; wasm = { };
unknown = { }; };
################################################################################
types.openKernelFamily = mkOptionType { name = "exec-format"; description = "executable container used by the kernel"; merge = mergeOneOption; };
types.kernelFamily = enum (attrValues kernelFamilies);
kernelFamilies = setTypes types.openKernelFamily { bsd = { }; darwin = { }; };
################################################################################
types.openKernel = mkOptionType { name = "kernel"; description = "kernel name and information"; merge = mergeOneOption; check = x: types.execFormat.check x.execFormat && all types.kernelFamily.check (attrValues x.families); };
types.kernel = enum (attrValues kernels);
kernels = let inherit (execFormats) elf pe wasm unknown macho ; inherit (kernelFamilies) bsd darwin; in setTypes types.openKernel { # TODO(@Ericson2314): Don't want to mass-rebuild yet to keeping 'darwin' as # the normalized name for macOS. macos = { execFormat = macho; families = { inherit darwin; }; name = "darwin"; }; ios = { execFormat = macho; families = { inherit darwin; }; }; freebsd = { execFormat = elf; families = { inherit bsd; }; name = "freebsd"; }; linux = { execFormat = elf; families = { }; }; netbsd = { execFormat = elf; families = { inherit bsd; }; }; none = { execFormat = unknown; families = { }; }; openbsd = { execFormat = elf; families = { inherit bsd; }; }; solaris = { execFormat = elf; families = { }; }; wasi = { execFormat = wasm; families = { }; }; redox = { execFormat = elf; families = { }; }; windows = { execFormat = pe; families = { }; }; ghcjs = { execFormat = unknown; families = { }; }; genode = { execFormat = elf; families = { }; }; mmixware = { execFormat = unknown; families = { }; }; } // { # aliases # 'darwin' is the kernel for all of them. We choose macOS by default. darwin = kernels.macos; watchos = kernels.ios; tvos = kernels.ios; win32 = kernels.windows; };
################################################################################
types.openAbi = mkOptionType { name = "abi"; description = "binary interface for compiled code and syscalls"; merge = mergeOneOption; };
types.abi = enum (attrValues abis);
abis = setTypes types.openAbi { 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: !(platform.isPower64 && platform.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 = { }; };
################################################################################
types.parsedPlatform = mkOptionType { name = "system"; description = "fully parsed representation of llvm- or nix-style platform tuple"; merge = mergeOneOption; check = { cpu, vendor, kernel, abi, }: types.cpuType.check cpu && types.vendor.check vendor && types.kernel.check kernel && types.abi.check abi; };
isSystem = isType "system";
mkSystem = components: assert types.parsedPlatform.check components; setType "system" components;
mkSkeletonFromList = l: { "1" = if elemAt l 0 == "avr" then { cpu = elemAt l 0; kernel = "none"; abi = "unknown"; } else throw "system string '${lib.concatStringsSep "-" l}' with 1 component is ambiguous"; "2" = # We only do 2-part hacks for things Nix already supports if elemAt l 1 == "cygwin" then { cpu = elemAt l 0; kernel = "windows"; abi = "cygnus"; } # MSVC ought to be the default ABI so this case isn't needed. But then it # becomes difficult to handle the gnu* variants for Aarch32 correctly for # minGW. So it's easier to make gnu* the default for the MinGW, but # hack-in MSVC for the non-MinGW case right here. else if elemAt l 1 == "windows" then { cpu = elemAt l 0; kernel = "windows"; abi = "msvc"; } else if (elemAt l 1) == "elf" then { cpu = elemAt l 0; vendor = "unknown"; kernel = "none"; abi = elemAt l 1; } else { cpu = elemAt l 0; kernel = elemAt l 1; }; "3" = # cpu-kernel-environment if elemAt l 1 == "linux" || elem (elemAt l 2) [ "eabi" "eabihf" "elf" "gnu" ] then { cpu = elemAt l 0; kernel = elemAt l 1; abi = elemAt l 2; vendor = "unknown"; } # cpu-vendor-os else if elemAt l 1 == "apple" || elem (elemAt l 2) [ "redox" "mmixware" "ghcjs" "mingw32" ] || hasPrefix "freebsd" (elemAt l 2) || hasPrefix "netbsd" (elemAt l 2) || hasPrefix "openbsd" (elemAt l 2) || hasPrefix "genode" (elemAt l 2) || hasPrefix "wasm32" (elemAt l 0) then { cpu = elemAt l 0; vendor = elemAt l 1; kernel = if elemAt l 2 == "mingw32" then "windows" # autotools breaks on -gnu for window else elemAt l 2; } else throw "system string '${lib.concatStringsSep "-" l}' with 3 components is ambiguous"; "4" = { cpu = elemAt l 0; vendor = elemAt l 1; kernel = elemAt l 2; abi = elemAt l 3; }; } .${toString (length l)} or (throw "system string '${lib.concatStringsSep "-" l}' has invalid number of hyphen-separated components");
# This should revert the job done by config.guess from the gcc compiler. mkSystemFromSkeleton = { cpu, # Optional, but fallback too complex for here. # Inferred below instead. vendor ? assert false; null, kernel, # Also inferred below abi ? assert false; null, }@args: let getCpu = name: cpuTypes.${name} or (throw "Unknown CPU type: ${name}"); getVendor = name: vendors.${name} or (throw "Unknown vendor: ${name}"); getKernel = name: kernels.${name} or (throw "Unknown kernel: ${name}"); getAbi = name: abis.${name} or (throw "Unknown ABI: ${name}");
parsed = { cpu = getCpu args.cpu; vendor = if args ? vendor then getVendor args.vendor else if isDarwin parsed then vendors.apple else if isWindows parsed then vendors.pc else vendors.unknown; kernel = if hasPrefix "darwin" args.kernel then getKernel "darwin" else if hasPrefix "netbsd" args.kernel then getKernel "netbsd" else getKernel (removeAbiSuffix args.kernel); abi = if args ? abi then getAbi args.abi else if isLinux parsed || isWindows parsed then if isAarch32 parsed then if versionAtLeast (parsed.cpu.version or "0") "6" then abis.gnueabihf else abis.gnueabi # Default ppc64 BE to ELFv2 else if isPower64 parsed && isBigEndian parsed then abis.gnuabielfv2 else abis.gnu else abis.unknown; };
in mkSystem parsed;
mkSystemFromString = s: mkSystemFromSkeleton (mkSkeletonFromList (splitString "-" s));
kernelName = kernel: kernel.name + toString (kernel.version or "");
darwinArch = cpu: if cpu.name == "aarch64" then "arm64" else cpu.name;
doubleFromSystem = { cpu, kernel, abi, ... }: if abi == abis.cygnus then "${cpu.name}-cygwin" else if kernel.families ? darwin then "${cpu.name}-darwin" else "${cpu.name}-${kernelName kernel}";
tripleFromSystem = { cpu, vendor, kernel, abi, ... }@sys: assert isSystem sys; let optExecFormat = optionalString ( kernel.name == "netbsd" && gnuNetBSDDefaultExecFormat cpu != kernel.execFormat ) kernel.execFormat.name; optAbi = optionalString (abi != abis.unknown) "-${abi.name}"; cpuName = if kernel.families ? darwin then darwinArch cpu else cpu.name; in "${cpuName}-${vendor.name}-${kernelName kernel}${optExecFormat}${optAbi}";
################################################################################
}