pkgs/stdenv/freebsd/default.nix

   1 # afaik the longest dependency chain is stdenv -> stdenv-1#coreutils -> stdenv-1#gmp -> stdenv-0#libcxx -> stdenv-0#libc
   2 # this is only possible through aggressive hacking to make libcxx build with stdenv-0#libc instead of bootstrapTools.libc.
   3 {
   4   lib,
   5   localSystem,
   6   crossSystem,
   7   config,
   8   overlays,
   9   crossOverlays ? [ ],
  10   bootstrapFiles ?
  11     let table = {
  12       x86_64-freebsd = import ./bootstrap-files/x86_64-unknown-freebsd.nix;
  13     };
  14     files = table.${localSystem.system} or (throw "unsupported platform ${localSystem.system} for the pure FreeBSD stdenv");
  15     in files
  16 }:
  17
  18 assert crossSystem == localSystem;
  19 let
  20   inherit (localSystem) system;
  21   mkExtraBuildCommands0 = cc: ''
  22     rsrc="$out/resource-root"
  23     mkdir "$rsrc"
  24     ln -s "${lib.getLib cc}/lib/clang/${lib.versions.major cc.version}/include" "$rsrc"
  25     echo "-resource-dir=$rsrc" >> $out/nix-support/cc-cflags
  26   '';
  27   mkExtraBuildCommands =
  28     cc: compiler-rt:
  29     mkExtraBuildCommands0 cc
  30     + ''
  31       ln -s "${compiler-rt.out}/lib" "$rsrc/lib"
  32       ln -s "${compiler-rt.out}/share" "$rsrc/share"
  33     '';
  34
  35   bootstrapArchive = (
  36     derivation {
  37       inherit system;
  38       name = "bootstrap-archive";
  39       pname = "bootstrap-archive";
  40       version = "9.9.9";
  41       builder = "${bootstrapFiles.unpack}/libexec/ld-elf.so.1";
  42       args = [ "${bootstrapFiles.unpack}/bin/bash" ./unpack-bootstrap-files.sh ];
  43       LD_LIBRARY_PATH = "${bootstrapFiles.unpack}/lib";
  44       src = bootstrapFiles.unpack;
  45       inherit (bootstrapFiles) bootstrapTools;
  46     }
  47   );
  48
  49   linkBootstrap = (
  50     attrs:
  51     derivation (
  52       attrs
  53       // {
  54         inherit system;
  55         name = attrs.name or (builtins.baseNameOf (builtins.elemAt attrs.paths 0));
  56         src = bootstrapArchive;
  57         builder = "${bootstrapArchive}/bin/bash";
  58         args = [ ./linkBootstrap.sh ];
  59         PATH = "${bootstrapArchive}/bin";
  60         paths = attrs.paths;
  61       }
  62     )
  63   );
  64
  65   # commented linkBootstrap entries are provided but unused
  66   bootstrapTools = {
  67     expand-response-params = "";
  68     bsdcp = linkBootstrap { paths = [ "bin/bsdcp" ]; };
  69     patchelf = linkBootstrap { paths = [ "bin/patchelf" ]; };
  70     bash = linkBootstrap {
  71       paths = [
  72         "bin/bash"
  73         "bin/sh"
  74       ];
  75       shell = "bin/bash";
  76       shellPath = "/bin/bash";
  77     };
  78     curl = linkBootstrap {
  79       paths = [
  80         "bin/curl"
  81       ];
  82     };
  83     llvmPackages = {
  84       clang-unwrapped = linkBootstrap {
  85         paths = [
  86           "bin/clang"
  87           "bin/clang++"
  88           "bin/cpp"
  89         ];
  90         # SYNCME: this version number must be synced with the one in make-bootstrap-tools.nix
  91         version = "18";
  92       };
  93       libunwind = linkBootstrap {
  94         name = "libunwind";
  95         paths = [
  96           "lib/libunwind.a"
  97           "lib/libunwind.so"
  98           "lib/libunwind.so.1"
  99           "lib/libunwind.so.1.0"
 100           "lib/libunwind_shared.so"
 101         ];
 102       };
 103     };
 104     coreutils = linkBootstrap {
 105       name = "coreutils";
 106       paths = map (str: "bin/" + str) [
 107         "base64"
 108         "basename"
 109         "cat"
 110         "chcon"
 111         "chgrp"
 112         "chmod"
 113         "chown"
 114         "chroot"
 115         "cksum"
 116         "comm"
 117         "cp"
 118         "csplit"
 119         "cut"
 120         "date"
 121         "dd"
 122         "df"
 123         "dir"
 124         "dircolors"
 125         "dirname"
 126         "du"
 127         "echo"
 128         "env"
 129         "expand"
 130         "expr"
 131         "factor"
 132         "false"
 133         "fmt"
 134         "fold"
 135         "groups"
 136         "head"
 137         "hostid"
 138         "id"
 139         "install"
 140         "join"
 141         "kill"
 142         "link"
 143         "ln"
 144         "logname"
 145         "ls"
 146         "md5sum"
 147         "mkdir"
 148         "mkfifo"
 149         "mknod"
 150         "mktemp"
 151         "mv"
 152         "nice"
 153         "nl"
 154         "nohup"
 155         "nproc"
 156         "numfmt"
 157         "od"
 158         "paste"
 159         "pathchk"
 160         "pinky"
 161         "pr"
 162         "printenv"
 163         "printf"
 164         "ptx"
 165         "pwd"
 166         "readlink"
 167         "realpath"
 168         "rm"
 169         "rmdir"
 170         "runcon"
 171         "seq"
 172         "shred"
 173         "shuf"
 174         "sleep"
 175         "sort"
 176         "split"
 177         "stat"
 178         "stdbuf"
 179         "stty"
 180         "sum"
 181         "tac"
 182         "tail"
 183         "tee"
 184         "test"
 185         "timeout"
 186         "touch"
 187         "tr"
 188         "true"
 189         "truncate"
 190         "tsort"
 191         "tty"
 192         "uname"
 193         "unexpand"
 194         "uniq"
 195         "unlink"
 196         "users"
 197         "vdir"
 198         "wc"
 199         "who"
 200         "whoami"
 201         "yes"
 202         "["
 203       ];
 204     };
 205     diffutils = linkBootstrap {
 206       name = "diffutils";
 207       paths = map (str: "bin/" + str) [
 208         "diff"
 209         "cmp"
 210         #"diff3"
 211         #"sdiff"
 212       ];
 213     };
 214     findutils = linkBootstrap {
 215       name = "findutils";
 216       paths = [
 217         "bin/find"
 218         "bin/xargs"
 219       ];
 220     };
 221     iconv = linkBootstrap { paths = [ "bin/iconv" ]; };
 222     patch = linkBootstrap { paths = [ "bin/patch" ]; };
 223     gnutar = linkBootstrap { paths = [ "bin/tar" ]; };
 224     gawk = linkBootstrap {
 225       paths = [
 226         "bin/awk"
 227         "bin/gawk"
 228       ];
 229     };
 230     gnumake = linkBootstrap { paths = [ "bin/make" ]; };
 231     gnugrep = linkBootstrap {
 232       paths = [
 233         "bin/grep"
 234         "bin/egrep"
 235         "bin/fgrep"
 236       ];
 237     };
 238     gnused = linkBootstrap { paths = [ "bin/sed" ]; };
 239     gzip = linkBootstrap {
 240       paths = [
 241         "bin/gzip"
 242         #"bin/gunzip"
 243       ];
 244     };
 245     bzip2 = linkBootstrap { paths = [ "bin/bzip2" ]; };
 246     xz = linkBootstrap {
 247       paths = [
 248         "bin/xz"
 249         "bin/unxz"
 250       ];
 251     };
 252     binutils-unwrapped = linkBootstrap {
 253       name = "binutils";
 254       paths = map (str: "bin/" + str) [
 255         "ld"
 256         #"as"
 257         #"addr2line"
 258         "ar"
 259         #"c++filt"
 260         #"elfedit"
 261         #"gprof"
 262         #"objdump"
 263         "nm"
 264         "objcopy"
 265         "ranlib"
 266         "readelf"
 267         "size"
 268         "strings"
 269         "strip"
 270       ];
 271     };
 272     freebsd = {
 273       locales = linkBootstrap { paths = [ "share/locale" ]; };
 274       libc = linkBootstrap {
 275         name = "bootstrapLibs";
 276         paths = [
 277           "lib"
 278           "include"
 279           "share"
 280           "libexec"
 281         ];
 282         pname = "libs";
 283         version = "bootstrap";
 284       };
 285     };
 286   };
 287
 288   mkStdenv =
 289     {
 290       name ? "freebsd",
 291       overrides ?
 292         prevStage: super: self:
 293         { },
 294       hascxx ? true,
 295     }:
 296     prevStage:
 297     let
 298       bsdcp =
 299         prevStage.bsdcp or (prevStage.runCommand "bsdcp" { }
 300           "mkdir -p $out/bin; cp ${prevStage.freebsd.cp}/bin/cp $out/bin/bsdcp"
 301         );
 302       initialPath = with prevStage; [
 303         coreutils
 304         gnutar
 305         findutils
 306         gnumake
 307         gnused
 308         patchelf
 309         gnugrep
 310         gawk
 311         diffutils
 312         patch
 313         bash
 314         xz
 315         gzip
 316         bzip2
 317         bsdcp
 318       ];
 319       shell = "${prevStage.bash}/bin/bash";
 320       stdenvNoCC = import ../generic {
 321         inherit
 322           config
 323           initialPath
 324           shell
 325           fetchurlBoot
 326           ;
 327         name = "stdenvNoCC-${name}";
 328         buildPlatform = localSystem;
 329         hostPlatform = localSystem;
 330         targetPlatform = localSystem;
 331         cc = null;
 332       };
 333       fetchurlBoot = import ../../build-support/fetchurl {
 334         inherit lib stdenvNoCC;
 335         inherit (prevStage) curl;
 336       };
 337       stdenv = import ../generic {
 338         inherit
 339           config
 340           initialPath
 341           shell
 342           fetchurlBoot
 343           ;
 344         name = "stdenv-${name}";
 345         buildPlatform = localSystem;
 346         hostPlatform = localSystem;
 347         targetPlatform = localSystem;
 348         extraNativeBuildInputs = [
 349           ./unpack-source.sh
 350           ./always-patchelf.sh
 351         ];
 352         cc = lib.makeOverridable (import ../../build-support/cc-wrapper) {
 353           inherit lib stdenvNoCC;
 354           name = "${name}-cc";
 355           inherit (prevStage.freebsd) libc;
 356           inherit (prevStage) gnugrep coreutils expand-response-params;
 357           libcxx = prevStage.llvmPackages.libcxx or null;
 358           runtimeShell = shell;
 359           propagateDoc = false;
 360           nativeTools = false;
 361           nativeLibc = false;
 362           cc = prevStage.llvmPackages.clang-unwrapped;
 363           isClang = true;
 364           extraPackages = lib.optionals hascxx [
 365             prevStage.llvmPackages.compiler-rt
 366           ];
 367           nixSupport = {
 368             libcxx-cxxflags = lib.optionals (!hascxx) [ "-isystem ${prevStage.freebsd.libc}/include/c++/v1" ];
 369           };
 370           extraBuildCommands = lib.optionalString hascxx (
 371             mkExtraBuildCommands prevStage.llvmPackages.clang-unwrapped prevStage.llvmPackages.compiler-rt
 372           );
 373           bintools = lib.makeOverridable (import ../../build-support/bintools-wrapper) {
 374             inherit lib stdenvNoCC;
 375             name = "${name}-bintools";
 376             inherit (prevStage.freebsd) libc;
 377             inherit (prevStage) gnugrep coreutils expand-response-params;
 378             runtimeShell = shell;
 379             bintools = prevStage.binutils-unwrapped;
 380             propagateDoc = false;
 381             nativeTools = false;
 382             nativeLibc = false;
 383           };
 384         };
 385         overrides = overrides prevStage;
 386         preHook = ''
 387           export NIX_ENFORCE_PURITY="''${NIX_ENFORCE_PURITY-1}"
 388           export NIX_ENFORCE_NO_NATIVE="''${NIX_ENFORCE_NO_NATIVE-1}"
 389           export PATH_LOCALE=${prevStage.freebsd.localesReal or prevStage.freebsd.locales}/share/locale
 390         '';
 391       };
 392     in
 393     {
 394       inherit config overlays stdenv;
 395     };
 396 in
 397 [
 398   (
 399     { }:
 400     mkStdenv {
 401       name = "freebsd-boot-0";
 402       hascxx = false;
 403       overrides = prevStage: self: super: {
 404         # this one's goal is to build foundational libs like libc and libcxx. we want to override literally every possible bin package we can with bootstrap tools
 405         # we CAN'T import LLVM because the compiler built here is used to build the final compiler and the final compiler must not be built by the bootstrap compiler
 406         inherit (bootstrapTools)
 407           patchelf
 408           bash
 409           curl
 410           coreutils
 411           diffutils
 412           findutils
 413           iconv
 414           patch
 415           gnutar
 416           gawk
 417           gnumake
 418           gnugrep
 419           gnused
 420           gzip
 421           bzip2
 422           xz
 423           ;
 424         binutils-unwrapped = builtins.removeAttrs bootstrapTools.binutils-unwrapped [ "src" ];
 425         fetchurl = import ../../build-support/fetchurl {
 426           inherit lib;
 427           inherit (self) stdenvNoCC;
 428           inherit (prevStage) curl;
 429         };
 430         gettext = super.gettext.overrideAttrs {
 431           NIX_CFLAGS_COMPILE = "-DHAVE_ICONV=1"; # we clearly have iconv. what do you want?
 432         };
 433         curlReal = super.curl;
 434         tzdata = super.tzdata.overrideAttrs { NIX_CFLAGS_COMPILE = "-DHAVE_GETTEXT=0"; };
 435
 436         # make it so libcxx/libunwind are built in this stdenv and not the next
 437         freebsd = super.freebsd.overrideScope (self': super': {
 438           inherit (prevStage.freebsd) locales;
 439               stdenvNoLibcxx =
 440                 self.overrideCC (self.stdenv // { name = "stdenv-freebsd-boot-0.4"; })
 441                   (
 442                     self.stdenv.cc.override {
 443                       name = "freebsd-boot-0.4-cc";
 444                       libc = self.freebsd.libc;
 445                       bintools = self.stdenv.cc.bintools.override {
 446                         name = "freebsd-boot-0.4-bintools";
 447                         libc = self.freebsd.libc;
 448                       };
 449                     }
 450                   );
 451         });
 452         llvmPackages = super.llvmPackages // {
 453           libcxx =
 454             (super.llvmPackages.libcxx.override {
 455               stdenv = self.overrideCC (self.stdenv // { name = "stdenv-freebsd-boot-0.5"; }) (
 456                 self.stdenv.cc.override {
 457                   name = "freebsd-boot-0.5-cc";
 458                   libc = self.freebsd.libc;
 459                   bintools = self.stdenv.cc.bintools.override {
 460                     name = "freebsd-boot-0.5-bintools";
 461                     libc = self.freebsd.libc;
 462                   };
 463                   extraPackages = [
 464                     self.llvmPackages.compiler-rt
 465                   ];
 466                   extraBuildCommands = mkExtraBuildCommands self.llvmPackages.clang-unwrapped self.llvmPackages.compiler-rt;
 467                 }
 468               );
 469             }).overrideAttrs
 470               (
 471                 self': super': {
 472                   NIX_CFLAGS_COMPILE = "-nostdlib++";
 473                   NIX_LDFLAGS = "--allow-shlib-undefined";
 474                   cmakeFlags = builtins.filter (x: x != "-DCMAKE_SHARED_LINKER_FLAGS=-nostdlib") super'.cmakeFlags;
 475                 }
 476               );
 477         };
 478       };
 479     } bootstrapTools
 480   )
 481   (mkStdenv {
 482     name = "freebsd-boot-1";
 483     overrides = prevStage: self: super: {
 484       # this one's goal is to build all the tools that get imported into the final stdenv.
 485       # we can import the foundational libs from boot-0
 486       # we can import bins and libs that DON'T get imported OR LINKED into the final stdenv from boot-0
 487       curl = prevStage.curlReal;
 488       inherit (prevStage)
 489         fetchurl
 490         python3
 491         bison
 492         perl
 493         cmake
 494         ninja
 495         ;
 496       fetchurlReal = super.fetchurl;
 497       freebsd = super.freebsd.overrideScope (
 498         self': super': {
 499           locales = prevStage.freebsd.locales;
 500           localesReal = super'.locales;
 501           libc = prevStage.freebsd.libc;
 502         }
 503       );
 504       llvmPackages = super.llvmPackages // {
 505         libcxx = prevStage.llvmPackages.libcxx;
 506       };
 507     };
 508   })
 509   (mkStdenv {
 510     name = "freebsd";
 511     overrides = prevStage: self: super: {
 512       __bootstrapArchive = bootstrapArchive;
 513       fetchurl = prevStage.fetchurlReal;
 514       freebsd = super.freebsd.overrideScope (
 515         self': super': { localesPrev = prevStage.freebsd.localesReal; }
 516       );
 517     };
 518   })
 519 ]