Rebuilding the world (with nix)

{ pkgs ? import <nixpkgs> {
    overlays = [
        (self: super:
            let
                # Use a different source tarball for gcc13
                gcc13cc = super.gcc13.cc.overrideAttrs (old: rec {
                    version = "13.1.0-mcdc";
                    src = super.fetchurl {
                        url = "file:///home/src/gcc/gcc-snapshot.tar.gz";
                        sha256 = "sha256:0000000000000000000000000000000000000000000000000000";
                    };
                    nativeBuildInputs = old.nativeBuildInputs ++ [super.flex];
                    patches = builtins.filter (p: builtins.baseNameOf p != "no-sys-dirs-riscv.patch") old.patches;
                });

                # haskell's compose: [f g h] env = h(g(f(env)))
                compose = fns: stdenv: builtins.foldl' (e: fn: fn e) stdenv fns;

                cflags  = super.withCFlags ["--coverage" "-fcondition-coverage"];
                ldflags = super.addAttrsToDerivation { NIX_CFLAGS_LINK = "--coverage"; }; # TODO: -lgcov
                # link perl modules with gcc, which properly links lcov
                plflags = super.addAttrsToDerivation { perlPreHook = "export LD=$CC"; };
                withcc  = cc: stdenv: super.overrideCC stdenv cc;
                gcc13   = super.gcc13.override { cc = gcc13cc; };
            in {
                gcc13Stdenv = compose [(withcc gcc13) cflags plflags] super.gcc13Stdenv;
            }
        )

        (self: super: {
            # skip check phase on libxcrypt as it uses --wrap, which seems to not
            # resolve -lgcov, probably linking order
            libxcrypt = super.libxcrypt.overrideAttrs (_: { doCheck = false; });

            # these packages are necessary to run the tests, so skipping the
            # tests entirely would be an alternative
            gnutls = super.gnutls.overrideAttrs (old: {
                buildInputs = old.buildInputs ++ [
                    super.openssl
                    super.datefudge
                    super.socat
                ];
            });

            libdaemon = super.libdaemon.overrideAttrs (old: {
                patches = old.patches ++ [./libdaemon-typedef-right-order.patch];
            });

            # libhwy's logical_tests never finished linking (?? no idea what this is)
            libhwy = super.libhwy.overrideAttrs (old: {
                doCheck = false;
            });

            zeromq = super.zeromq.overrideAttrs (old: {
                # this is applied in upstream nixpkgs, so for future proofing
                # this must be checked to not be applied twice.
                patches = (old.patches or []) ++ [
                    # Backport gcc-13 fix:
                    #   https://github.com/zeromq/libzmq/pull/4480
                    (self.fetchpatch {
                        name = "gcc-13.patch";
                        url  = "https://github.com/zeromq/libzmq/commit/438d5d88392baffa6c2c5e0737d9de19d6686f0d.patch";
                        hash = "sha256-tSTYSrQzgnfbY/70QhPdOnpEXX05VAYwVYuW8P1LWf0=";
                    })
                ];
            });

            openexr = super.openexr.overrideAttrs (old: {
                patches = old.patches ++ [./0001-openexr-include-cstdint.patch];
            });

            # the elfutils tests cannot find rpm2cpio. rpm depends on rpm2cpio
            # so either the rpm source must be impure, or we must skip the
            # test. The latter is easier for this purpose.
            elfutils = super.elfutils.overrideAttrs (_: {
                doCheck = false;
                doInstallCheck = false;
            });
        })

        # on gcc13 the llvm tree does not build, which is a known problem and fixed with a small patch
        # https://github.com/JuliaLang/llvm-project/commit/ff1681ddb303223973653f7f5f3f3435b48a1983
        #
        # compiler-rt is problematic because -ffreestanding removes
        # declarations like free, malloc, strtoull from stdlib.h. The flag is
        # used to disable a particular optimization in clang but only gcc is
        # used, and the sanitizers (where this happen) are not interesting.
        # 
        # running the tests takes for ever and is pretty uninteresting for this
        # experiment so they are disabled too.
        (self: super:
            let
                patch = pkg: patches: pkg.overrideAttrs (old: {
                    patches = (old.patches or []) ++ patches;
                    doCheck = false;
                });
                llvm-patches        = [./0001-include-cstdint-llvm11.patch];
                compiler-rt-patches = [./0001-compiler-rt-no-ffreestanding.patch];
            in {
                llvmPackages_11 = super.llvmPackages_11 // {
                    libraries = super.llvmPackages_11.libraries.extend(lfinal: lprev: {
                        libcxx      = patch lprev.libcxx    llvm-patches;
                        libcxxabi   = patch lprev.libcxxabi llvm-patches;
                        compiler-rt-libc    = patch lprev.compiler-rt-libc    compiler-rt-patches;
                        compiler-rt-no-libc = patch lprev.compiler-rt-no-libc compiler-rt-patches;
                    });
                    tools = super.llvmPackages_11.tools.extend(lfinal: lprev: {
                        libllvm  = patch lprev.libllvm llvm-patches;
                        libcxxClang = lprev.libcxxClang.overrideAttrs (old: {
                            setupHooks = old.setupHooks ++ [./no-fprofile.sh];
                        });
                        libstdcxxClang = lprev.libstdcxxClang.overrideAttrs (old: {
                            setupHooks = old.setupHooks ++ [./no-fprofile.sh];
                        });
                    });

                    # we also bring in the other attrs because they still
                    # capture the old package. Doing this manually is not great
                    # and there should be a programmatic solution
                    inherit (self.llvmPackages_11.tools)     libllvm clang;
                    inherit (self.llvmPackages_11.libraries) compiler-rt;
                };
            }
        )

        # python's cffi tests building modules and check that only the expected
        # artifacts are produced, which breaks with gcov because the .gcno
        # files are generated too. It also adds extra symbols cffi does not
        # expect, so the no_unknown_exported_symbols test fails.
        (self: super: {
            python310 = super.python310.override {
                packageOverrides = pyself: pysuper: {
                    cffi = pysuper.cffi.overrideAttrs(old: {
                        disabledTests = old.disabledTests ++ [
                            "test_no_unknown_exported_symbols"
                            "test_api_compile_1"
                            "test_api_compile_2"
                            "test_api_compile_3"
                            "test_api_compile_explicit_target_1"
                            "test_api_compile_explicit_target_2"
                            "test_api_compile_explicit_target_3"
                        ];
                    });
                };
            };
        })

        # valgrind, systemd builds with -fprofile-coverage which is all good,
        # but the link fails because they do not link to libc (-nostdlib) which
        # means the fwrite etc. calls in libgcov do not resolve. Since we have
        # the information we need at this point we can just build them without
        # mcdc.
        (self: super: 
            let no-fcondition-coverage = pkg: pkg.overrideDerivation (old: {
                    NIX_CFLAGS_COMPILE = builtins.replaceStrings
                        ["--coverage" "-fcondition-coverage"] ["" ""]
                        old.NIX_CFLAGS_COMPILE;
                });
            in {
                valgrind = no-fcondition-coverage super.valgrind;
                systemd  = no-fcondition-coverage super.systemd;
                gnu-efi  = no-fcondition-coverage super.gnu-efi;
        })
    ];
    config.replaceStdenv = { pkgs, ... }: pkgs.gcc13Stdenv;
}}:

pkgs.mkShell { 
    inputs = with pkgs; [
        tree
        cpio
        git
        icu
        openjdk
    ];
}