lib/systems/parse.nix

   1 # Define the list of system with their properties.
   2 #
   3 # See https://clang.llvm.org/docs/CrossCompilation.html and
   4 # http://llvm.org/docs/doxygen/html/Triple_8cpp_source.html especially
   5 # Triple::normalize. Parsing should essentially act as a more conservative
   6 # version of that last function.
   7 #
   8 # Most of the types below come in "open" and "closed" pairs. The open ones
   9 # specify what information we need to know about systems in general, and the
  10 # closed ones are sub-types representing the whitelist of systems we support in
  11 # practice.
  12 #
  13 # Code in the remainder of nixpkgs shouldn't rely on the closed ones in
  14 # e.g. exhaustive cases. Its more a sanity check to make sure nobody defines
  15 # systems that overlap with existing ones and won't notice something amiss.
  16 #
  17 { lib }:
  18 with lib.lists;
  19 with lib.types;
  20 with lib.attrsets;
  21 with lib.strings;
  22 with (import ./inspect.nix { inherit lib; }).predicates;
  23
  24 let
  25   inherit (lib.options) mergeOneOption;
  26
  27   setTypes = type:
  28     mapAttrs (name: value:
  29       assert type.check value;
  30       setType type.name ({ inherit name; } // value));
  31
  32 in
  33
  34 rec {
  35
  36   ################################################################################
  37
  38   types.openSignificantByte = mkOptionType {
  39     name = "significant-byte";
  40     description = "Endianness";
  41     merge = mergeOneOption;
  42   };
  43
  44   types.significantByte = enum (attrValues significantBytes);
  45
  46   significantBytes = setTypes types.openSignificantByte {
  47     bigEndian = {};
  48     littleEndian = {};
  49   };
  50
  51   ################################################################################
  52
  53   # Reasonable power of 2
  54   types.bitWidth = enum [ 8 16 32 64 128 ];
  55
  56   ################################################################################
  57
  58   types.openCpuType = mkOptionType {
  59     name = "cpu-type";
  60     description = "instruction set architecture name and information";
  61     merge = mergeOneOption;
  62     check = x: types.bitWidth.check x.bits
  63       && (if 8 < x.bits
  64           then types.significantByte.check x.significantByte
  65           else !(x ? significantByte));
  66   };
  67
  68   types.cpuType = enum (attrValues cpuTypes);
  69
  70   cpuTypes = with significantBytes; setTypes types.openCpuType {
  71     arm      = { bits = 32; significantByte = littleEndian; family = "arm"; };
  72     armv5tel = { bits = 32; significantByte = littleEndian; family = "arm"; version = "5"; arch = "armv5t"; };
  73     armv6m   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "6"; arch = "armv6-m"; };
  74     armv6l   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "6"; arch = "armv6"; };
  75     armv7a   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "7"; arch = "armv7-a"; };
  76     armv7r   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "7"; arch = "armv7-r"; };
  77     armv7m   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "7"; arch = "armv7-m"; };
  78     armv7l   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "7"; arch = "armv7"; };
  79     armv8a   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "8"; arch = "armv8-a"; };
  80     armv8r   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "8"; arch = "armv8-a"; };
  81     armv8m   = { bits = 32; significantByte = littleEndian; family = "arm"; version = "8"; arch = "armv8-m"; };
  82     aarch64  = { bits = 64; significantByte = littleEndian; family = "arm"; version = "8"; arch = "armv8-a"; };
  83     aarch64_be = { bits = 64; significantByte = bigEndian; family = "arm"; version = "8";  arch = "armv8-a"; };
  84
  85     i386     = { bits = 32; significantByte = littleEndian; family = "x86"; arch = "i386"; };
  86     i486     = { bits = 32; significantByte = littleEndian; family = "x86"; arch = "i486"; };
  87     i586     = { bits = 32; significantByte = littleEndian; family = "x86"; arch = "i586"; };
  88     i686     = { bits = 32; significantByte = littleEndian; family = "x86"; arch = "i686"; };
  89     x86_64   = { bits = 64; significantByte = littleEndian; family = "x86"; arch = "x86-64"; };
  90
  91     microblaze   = { bits = 32; significantByte = bigEndian;    family = "microblaze"; };
  92     microblazeel = { bits = 32; significantByte = littleEndian; family = "microblaze"; };
  93
  94     mips     = { bits = 32; significantByte = bigEndian;    family = "mips"; };
  95     mipsel   = { bits = 32; significantByte = littleEndian; family = "mips"; };
  96     mips64   = { bits = 64; significantByte = bigEndian;    family = "mips"; };
  97     mips64el = { bits = 64; significantByte = littleEndian; family = "mips"; };
  98
  99     mmix     = { bits = 64; significantByte = bigEndian;    family = "mmix"; };
 100
 101     m68k     = { bits = 32; significantByte = bigEndian; family = "m68k"; };
 102
 103     powerpc  = { bits = 32; significantByte = bigEndian;    family = "power"; };
 104     powerpc64 = { bits = 64; significantByte = bigEndian; family = "power"; };
 105     powerpc64le = { bits = 64; significantByte = littleEndian; family = "power"; };
 106     powerpcle = { bits = 32; significantByte = littleEndian; family = "power"; };
 107
 108     riscv32  = { bits = 32; significantByte = littleEndian; family = "riscv"; };
 109     riscv64  = { bits = 64; significantByte = littleEndian; family = "riscv"; };
 110
 111     s390     = { bits = 32; significantByte = bigEndian; family = "s390"; };
 112     s390x    = { bits = 64; significantByte = bigEndian; family = "s390"; };
 113
 114     sparc    = { bits = 32; significantByte = bigEndian;    family = "sparc"; };
 115     sparc64  = { bits = 64; significantByte = bigEndian;    family = "sparc"; };
 116
 117     wasm32   = { bits = 32; significantByte = littleEndian; family = "wasm"; };
 118     wasm64   = { bits = 64; significantByte = littleEndian; family = "wasm"; };
 119
 120     alpha    = { bits = 64; significantByte = littleEndian; family = "alpha"; };
 121
 122     rx       = { bits = 32; significantByte = littleEndian; family = "rx"; };
 123     msp430   = { bits = 16; significantByte = littleEndian; family = "msp430"; };
 124     avr      = { bits = 8; family = "avr"; };
 125
 126     vc4      = { bits = 32; significantByte = littleEndian; family = "vc4"; };
 127
 128     or1k     = { bits = 32; significantByte = bigEndian; family = "or1k"; };
 129
 130     js       = { bits = 32; significantByte = littleEndian; family = "js"; };
 131   };
 132
 133   # GNU build systems assume that older NetBSD architectures are using a.out.
 134   gnuNetBSDDefaultExecFormat = cpu:
 135     if (cpu.family == "arm" && cpu.bits == 32) ||
 136        (cpu.family == "sparc" && cpu.bits == 32) ||
 137        (cpu.family == "m68k" && cpu.bits == 32) ||
 138        (cpu.family == "x86" && cpu.bits == 32)
 139     then execFormats.aout
 140     else execFormats.elf;
 141
 142   # Determine when two CPUs are compatible with each other. That is,
 143   # can code built for system B run on system A? For that to happen,
 144   # the programs that system B accepts must be a subset of the
 145   # programs that system A accepts.
 146   #
 147   # We have the following properties of the compatibility relation,
 148   # which must be preserved when adding compatibility information for
 149   # additional CPUs.
 150   # - (reflexivity)
 151   #   Every CPU is compatible with itself.
 152   # - (transitivity)
 153   #   If A is compatible with B and B is compatible with C then A is compatible with C.
 154   #
 155   # Note: Since 22.11 the archs of a mode switching CPU are no longer considered
 156   # pairwise compatible. Mode switching implies that binaries built for A
 157   # and B respectively can't be executed at the same time.
 158   isCompatible = a: b: with cpuTypes; lib.any lib.id [
 159     # x86
 160     (b == i386 && isCompatible a i486)
 161     (b == i486 && isCompatible a i586)
 162     (b == i586 && isCompatible a i686)
 163
 164     # XXX: Not true in some cases. Like in WSL mode.
 165     (b == i686 && isCompatible a x86_64)
 166
 167     # ARMv4
 168     (b == arm && isCompatible a armv5tel)
 169
 170     # ARMv5
 171     (b == armv5tel && isCompatible a armv6l)
 172
 173     # ARMv6
 174     (b == armv6l && isCompatible a armv6m)
 175     (b == armv6m && isCompatible a armv7l)
 176
 177     # ARMv7
 178     (b == armv7l && isCompatible a armv7a)
 179     (b == armv7l && isCompatible a armv7r)
 180     (b == armv7l && isCompatible a armv7m)
 181     (b == armv7a && isCompatible a armv8a)
 182     (b == armv7r && isCompatible a armv8a)
 183     (b == armv7m && isCompatible a armv8a)
 184     (b == armv7a && isCompatible a armv8r)
 185     (b == armv7r && isCompatible a armv8r)
 186     (b == armv7m && isCompatible a armv8r)
 187     (b == armv7a && isCompatible a armv8m)
 188     (b == armv7r && isCompatible a armv8m)
 189     (b == armv7m && isCompatible a armv8m)
 190
 191     # ARMv8
 192     (b == armv8r && isCompatible a armv8a)
 193     (b == armv8m && isCompatible a armv8a)
 194
 195     # XXX: not always true! Some arm64 cpus don’t support arm32 mode.
 196     (b == aarch64 && a == armv8a)
 197     (b == armv8a && isCompatible a aarch64)
 198
 199     # PowerPC
 200     (b == powerpc && isCompatible a powerpc64)
 201     (b == powerpcle && isCompatible a powerpc64le)
 202
 203     # MIPS
 204     (b == mips && isCompatible a mips64)
 205     (b == mipsel && isCompatible a mips64el)
 206
 207     # RISCV
 208     (b == riscv32 && isCompatible a riscv64)
 209
 210     # SPARC
 211     (b == sparc && isCompatible a sparc64)
 212
 213     # WASM
 214     (b == wasm32 && isCompatible a wasm64)
 215
 216     # identity
 217     (b == a)
 218   ];
 219
 220   ################################################################################
 221
 222   types.openVendor = mkOptionType {
 223     name = "vendor";
 224     description = "vendor for the platform";
 225     merge = mergeOneOption;
 226   };
 227
 228   types.vendor = enum (attrValues vendors);
 229
 230   vendors = setTypes types.openVendor {
 231     apple = {};
 232     pc = {};
 233     # Actually matters, unlocking some MinGW-w64-specific options in GCC. See
 234     # bottom of https://sourceforge.net/p/mingw-w64/wiki2/Unicode%20apps/
 235     w64 = {};
 236
 237     none = {};
 238     unknown = {};
 239   };
 240
 241   ################################################################################
 242
 243   types.openExecFormat = mkOptionType {
 244     name = "exec-format";
 245     description = "executable container used by the kernel";
 246     merge = mergeOneOption;
 247   };
 248
 249   types.execFormat = enum (attrValues execFormats);
 250
 251   execFormats = setTypes types.openExecFormat {
 252     aout = {}; # a.out
 253     elf = {};
 254     macho = {};
 255     pe = {};
 256     wasm = {};
 257
 258     unknown = {};
 259   };
 260
 261   ################################################################################
 262
 263   types.openKernelFamily = mkOptionType {
 264     name = "exec-format";
 265     description = "executable container used by the kernel";
 266     merge = mergeOneOption;
 267   };
 268
 269   types.kernelFamily = enum (attrValues kernelFamilies);
 270
 271   kernelFamilies = setTypes types.openKernelFamily {
 272     bsd = {};
 273     darwin = {};
 274   };
 275
 276   ################################################################################
 277
 278   types.openKernel = mkOptionType {
 279     name = "kernel";
 280     description = "kernel name and information";
 281     merge = mergeOneOption;
 282     check = x: types.execFormat.check x.execFormat
 283         && all types.kernelFamily.check (attrValues x.families);
 284   };
 285
 286   types.kernel = enum (attrValues kernels);
 287
 288   kernels = with execFormats; with kernelFamilies; setTypes types.openKernel {
 289     # TODO(@Ericson2314): Don't want to mass-rebuild yet to keeping 'darwin' as
 290     # the normalized name for macOS.
 291     macos    = { execFormat = macho;   families = { inherit darwin; }; name = "darwin"; };
 292     ios      = { execFormat = macho;   families = { inherit darwin; }; };
 293     # A tricky thing about FreeBSD is that there is no stable ABI across
 294     # versions. That means that putting in the version as part of the
 295     # config string is paramount.
 296     freebsd12 = { execFormat = elf;     families = { inherit bsd; }; name = "freebsd"; version = 12; };
 297     freebsd13 = { execFormat = elf;     families = { inherit bsd; }; name = "freebsd"; version = 13; };
 298     linux    = { execFormat = elf;     families = { }; };
 299     netbsd   = { execFormat = elf;     families = { inherit bsd; }; };
 300     none     = { execFormat = unknown; families = { }; };
 301     openbsd  = { execFormat = elf;     families = { inherit bsd; }; };
 302     solaris  = { execFormat = elf;     families = { }; };
 303     wasi     = { execFormat = wasm;    families = { }; };
 304     redox    = { execFormat = elf;     families = { }; };
 305     windows  = { execFormat = pe;      families = { }; };
 306     ghcjs    = { execFormat = unknown; families = { }; };
 307     genode   = { execFormat = elf;     families = { }; };
 308     mmixware = { execFormat = unknown; families = { }; };
 309   } // { # aliases
 310     # 'darwin' is the kernel for all of them. We choose macOS by default.
 311     darwin = kernels.macos;
 312     watchos = kernels.ios;
 313     tvos = kernels.ios;
 314     win32 = kernels.windows;
 315   };
 316
 317   ################################################################################
 318
 319   types.openAbi = mkOptionType {
 320     name = "abi";
 321     description = "binary interface for compiled code and syscalls";
 322     merge = mergeOneOption;
 323   };
 324
 325   types.abi = enum (attrValues abis);
 326
 327   abis = setTypes types.openAbi {
 328     cygnus       = {};
 329     msvc         = {};
 330
 331     # Note: eabi is specific to ARM and PowerPC.
 332     # On PowerPC, this corresponds to PPCEABI.
 333     # On ARM, this corresponds to ARMEABI.
 334     eabi         = { float = "soft"; };
 335     eabihf       = { float = "hard"; };
 336
 337     # Other architectures should use ELF in embedded situations.
 338     elf          = {};
 339
 340     androideabi  = {};
 341     android      = {
 342       assertions = [
 343         { assertion = platform: !platform.isAarch32;
 344           message = ''
 345             The "android" ABI is not for 32-bit ARM. Use "androideabi" instead.
 346           '';
 347         }
 348       ];
 349     };
 350
 351     gnueabi      = { float = "soft"; };
 352     gnueabihf    = { float = "hard"; };
 353     gnu          = {
 354       assertions = [
 355         { assertion = platform: !platform.isAarch32;
 356           message = ''
 357             The "gnu" ABI is ambiguous on 32-bit ARM. Use "gnueabi" or "gnueabihf" instead.
 358           '';
 359         }
 360         { assertion = platform: with platform; !(isPower64 && isBigEndian);
 361           message = ''
 362             The "gnu" ABI is ambiguous on big-endian 64-bit PowerPC. Use "gnuabielfv2" or "gnuabielfv1" instead.
 363           '';
 364         }
 365       ];
 366     };
 367     gnuabi64     = { abi = "64"; };
 368     muslabi64    = { abi = "64"; };
 369
 370     # NOTE: abi=n32 requires a 64-bit MIPS chip!  That is not a typo.
 371     # It is basically the 64-bit abi with 32-bit pointers.  Details:
 372     # https://www.linux-mips.org/pub/linux/mips/doc/ABI/MIPS-N32-ABI-Handbook.pdf
 373     gnuabin32    = { abi = "n32"; };
 374     muslabin32   = { abi = "n32"; };
 375
 376     gnuabielfv2  = { abi = "elfv2"; };
 377     gnuabielfv1  = { abi = "elfv1"; };
 378
 379     musleabi     = { float = "soft"; };
 380     musleabihf   = { float = "hard"; };
 381     musl         = {};
 382
 383     uclibceabi   = { float = "soft"; };
 384     uclibceabihf = { float = "hard"; };
 385     uclibc       = {};
 386
 387     unknown = {};
 388   };
 389
 390   ################################################################################
 391
 392   types.parsedPlatform = mkOptionType {
 393     name = "system";
 394     description = "fully parsed representation of llvm- or nix-style platform tuple";
 395     merge = mergeOneOption;
 396     check = { cpu, vendor, kernel, abi }:
 397            types.cpuType.check cpu
 398         && types.vendor.check vendor
 399         && types.kernel.check kernel
 400         && types.abi.check abi;
 401   };
 402
 403   isSystem = isType "system";
 404
 405   mkSystem = components:
 406     assert types.parsedPlatform.check components;
 407     setType "system" components;
 408
 409   mkSkeletonFromList = l: {
 410     "1" = if elemAt l 0 == "avr"
 411       then { cpu = elemAt l 0; kernel = "none"; abi = "unknown"; }
 412       else throw "Target specification with 1 components is ambiguous";
 413     "2" = # We only do 2-part hacks for things Nix already supports
 414       if elemAt l 1 == "cygwin"
 415         then { cpu = elemAt l 0;                      kernel = "windows";  abi = "cygnus";   }
 416       # MSVC ought to be the default ABI so this case isn't needed. But then it
 417       # becomes difficult to handle the gnu* variants for Aarch32 correctly for
 418       # minGW. So it's easier to make gnu* the default for the MinGW, but
 419       # hack-in MSVC for the non-MinGW case right here.
 420       else if elemAt l 1 == "windows"
 421         then { cpu = elemAt l 0;                      kernel = "windows";  abi = "msvc";     }
 422       else if (elemAt l 1) == "elf"
 423         then { cpu = elemAt l 0; vendor = "unknown";  kernel = "none";     abi = elemAt l 1; }
 424       else   { cpu = elemAt l 0;                      kernel = elemAt l 1;                   };
 425     "3" = # Awkward hacks, beware!
 426       if elemAt l 1 == "apple"
 427         then { cpu = elemAt l 0; vendor = "apple";    kernel = elemAt l 2;                   }
 428       else if (elemAt l 1 == "linux") || (elemAt l 2 == "gnu")
 429         then { cpu = elemAt l 0;                      kernel = elemAt l 1; abi = elemAt l 2; }
 430       else if (elemAt l 2 == "mingw32") # autotools breaks on -gnu for window
 431         then { cpu = elemAt l 0; vendor = elemAt l 1; kernel = "windows";                    }
 432       else if (elemAt l 2 == "wasi")
 433         then { cpu = elemAt l 0; vendor = elemAt l 1; kernel = "wasi";                       }
 434       else if (elemAt l 2 == "redox")
 435         then { cpu = elemAt l 0; vendor = elemAt l 1; kernel = "redox";                      }
 436       else if (elemAt l 2 == "mmixware")
 437         then { cpu = elemAt l 0; vendor = elemAt l 1; kernel = "mmixware";                   }
 438       else if hasPrefix "freebsd" (elemAt l 2)
 439         then { cpu = elemAt l 0; vendor = elemAt l 1;    kernel = elemAt l 2;                }
 440       else if hasPrefix "netbsd" (elemAt l 2)
 441         then { cpu = elemAt l 0; vendor = elemAt l 1;    kernel = elemAt l 2;                }
 442       else if (elem (elemAt l 2) ["eabi" "eabihf" "elf"])
 443         then { cpu = elemAt l 0; vendor = "unknown"; kernel = elemAt l 1; abi = elemAt l 2; }
 444       else if (elemAt l 2 == "ghcjs")
 445         then { cpu = elemAt l 0; vendor = "unknown"; kernel = elemAt l 2; }
 446       else if hasPrefix "genode" (elemAt l 2)
 447         then { cpu = elemAt l 0; vendor = elemAt l 1; kernel = elemAt l 2; }
 448       else throw "Target specification with 3 components is ambiguous";
 449     "4" =    { cpu = elemAt l 0; vendor = elemAt l 1; kernel = elemAt l 2; abi = elemAt l 3; };
 450   }.${toString (length l)}
 451     or (throw "system string has invalid number of hyphen-separated components");
 452
 453   # This should revert the job done by config.guess from the gcc compiler.
 454   mkSystemFromSkeleton = { cpu
 455                          , # Optional, but fallback too complex for here.
 456                            # Inferred below instead.
 457                            vendor ? assert false; null
 458                          , kernel
 459                          , # Also inferred below
 460                            abi    ? assert false; null
 461                          } @ args: let
 462     getCpu    = name: cpuTypes.${name} or (throw "Unknown CPU type: ${name}");
 463     getVendor = name:  vendors.${name} or (throw "Unknown vendor: ${name}");
 464     getKernel = name:  kernels.${name} or (throw "Unknown kernel: ${name}");
 465     getAbi    = name:     abis.${name} or (throw "Unknown ABI: ${name}");
 466
 467     parsed = {
 468       cpu = getCpu args.cpu;
 469       vendor =
 470         /**/ if args ? vendor    then getVendor args.vendor
 471         else if isDarwin  parsed then vendors.apple
 472         else if isWindows parsed then vendors.pc
 473         else                     vendors.unknown;
 474       kernel = if hasPrefix "darwin" args.kernel      then getKernel "darwin"
 475                else if hasPrefix "netbsd" args.kernel then getKernel "netbsd"
 476                else                                   getKernel args.kernel;
 477       abi =
 478         /**/ if args ? abi       then getAbi args.abi
 479         else if isLinux parsed || isWindows parsed then
 480           if isAarch32 parsed then
 481             if lib.versionAtLeast (parsed.cpu.version or "0") "6"
 482             then abis.gnueabihf
 483             else abis.gnueabi
 484           # Default ppc64 BE to ELFv2
 485           else if isPower64 parsed && isBigEndian parsed then abis.gnuabielfv2
 486           else abis.gnu
 487         else                     abis.unknown;
 488     };
 489
 490   in mkSystem parsed;
 491
 492   mkSystemFromString = s: mkSystemFromSkeleton (mkSkeletonFromList (lib.splitString "-" s));
 493
 494   kernelName = kernel:
 495     kernel.name + toString (kernel.version or "");
 496
 497   doubleFromSystem = { cpu, kernel, abi, ... }:
 498     /**/ if abi == abis.cygnus       then "${cpu.name}-cygwin"
 499     else if kernel.families ? darwin then "${cpu.name}-darwin"
 500     else "${cpu.name}-${kernelName kernel}";
 501
 502   tripleFromSystem = { cpu, vendor, kernel, abi, ... } @ sys: assert isSystem sys; let
 503     optExecFormat =
 504       lib.optionalString (kernel.name == "netbsd" &&
 505                           gnuNetBSDDefaultExecFormat cpu != kernel.execFormat)
 506         kernel.execFormat.name;
 507     optAbi = lib.optionalString (abi != abis.unknown) "-${abi.name}";
 508   in "${cpu.name}-${vendor.name}-${kernelName kernel}${optExecFormat}${optAbi}";
 509
 510   ################################################################################
 511
 512 }