pkgs/development/compilers/ghc/8.10.7.nix

   1 { lib, stdenv, pkgsBuildTarget, pkgsHostTarget, buildPackages, targetPackages
   2
   3 # build-tools
   4 , bootPkgs
   5 , autoreconfHook, autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx
   6 , xattr, autoSignDarwinBinariesHook
   7 , bash
   8
   9 , libiconv ? null, ncurses
  10
  11 , # GHC can be built with system libffi or a bundled one.
  12   # we explicitly use libffi-3.3 here because 3.4 removes a flag that causes
  13   # problems for ghc-8.10.7's RTS. See #324384.
  14   # Save for aarch_darwin since libffi-3.3 is broken there but the issue isn't present anyway
  15   libffi ? null
  16 , libffi_3_3 ? null
  17
  18 , useLLVM ? !(stdenv.targetPlatform.isx86
  19               || stdenv.targetPlatform.isPower
  20               || stdenv.targetPlatform.isSparc)
  21 , # LLVM is conceptually a run-time-only dependency, but for
  22   # non-x86, we need LLVM to bootstrap later stages, so it becomes a
  23   # build-time dependency too.
  24   buildTargetLlvmPackages, llvmPackages
  25
  26 , # If enabled, GHC will be built with the GPL-free but slower integer-simple
  27   # library instead of the faster but GPLed integer-gmp library.
  28   enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp
  29                           && lib.meta.availableOn stdenv.targetPlatform gmp)
  30 , gmp
  31
  32 , # If enabled, use -fPIC when compiling static libs.
  33   enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
  34
  35   # Exceeds Hydra output limit (at the time of writing ~3GB) when cross compiled to riscv64.
  36   # A riscv64 cross-compiler fits into the limit comfortably.
  37 , enableProfiledLibs ? !stdenv.hostPlatform.isRiscV64
  38
  39 , # Whether to build dynamic libs for the standard library (on the target
  40   # platform). Static libs are always built.
  41   enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
  42
  43 , # Whether to build terminfo.
  44   enableTerminfo ? !(stdenv.targetPlatform.isWindows
  45                      # terminfo can't be built for cross
  46                      || (stdenv.buildPlatform != stdenv.hostPlatform)
  47                      || (stdenv.hostPlatform != stdenv.targetPlatform))
  48
  49 , # What flavour to build. An empty string indicates no
  50   # specific flavour and falls back to ghc default values.
  51   ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
  52     (if useLLVM then "perf-cross" else "perf-cross-ncg")
  53
  54 , #  Whether to build sphinx documentation.
  55   enableDocs ? (
  56     # Docs disabled if we are building on musl because it's a large task to keep
  57     # all `sphinx` dependencies building in this environment.
  58     !stdenv.buildPlatform.isMusl
  59   )
  60
  61 , enableHaddockProgram ?
  62     # Disabled for cross; see note [HADDOCK_DOCS].
  63     (stdenv.buildPlatform == stdenv.hostPlatform && stdenv.targetPlatform == stdenv.hostPlatform)
  64
  65 , # Whether to disable the large address space allocator
  66   # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
  67   disableLargeAddressSpace ? stdenv.targetPlatform.isiOS
  68
  69 , # Whether to build an unregisterised version of GHC.
  70   # GHC will normally auto-detect whether it can do a registered build, but this
  71   # option will force it to do an unregistered build when set to true.
  72   # See https://gitlab.haskell.org/ghc/ghc/-/wikis/building/unregisterised
  73   enableUnregisterised ? false
  74 }@args:
  75
  76 assert !enableIntegerSimple -> gmp != null;
  77
  78 # Cross cannot currently build the `haddock` program for silly reasons,
  79 # see note [HADDOCK_DOCS].
  80 assert (stdenv.buildPlatform != stdenv.hostPlatform || stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram;
  81
  82 # GHC does not support building when all 3 platforms are different.
  83 assert stdenv.buildPlatform == stdenv.hostPlatform || stdenv.hostPlatform == stdenv.targetPlatform;
  84
  85 let
  86   inherit (stdenv) buildPlatform hostPlatform targetPlatform;
  87
  88   # TODO(@Ericson2314) Make unconditional
  89   targetPrefix = lib.optionalString
  90     (targetPlatform != hostPlatform)
  91     "${targetPlatform.config}-";
  92
  93   buildMK = ''
  94     BuildFlavour = ${ghcFlavour}
  95     ifneq \"\$(BuildFlavour)\" \"\"
  96     include mk/flavours/\$(BuildFlavour).mk
  97     endif
  98     BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"}
  99     BUILD_SPHINX_PDF = NO
 100
 101     WITH_TERMINFO = ${if enableTerminfo then "YES" else "NO"}
 102   '' +
 103   # Note [HADDOCK_DOCS]:
 104   # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock`
 105   # program is built (which we generally always want to have a complete GHC install)
 106   # and whether it is run on the GHC sources to generate hyperlinked source code
 107   # (which is impossible for cross-compilation); see:
 108   # https://gitlab.haskell.org/ghc/ghc/-/issues/20077
 109   # This implies that currently a cross-compiled GHC will never have a `haddock`
 110   # program, so it can never generate haddocks for any packages.
 111   # If this is solved in the future, we'd like to unconditionally
 112   # build the haddock program (removing the `enableHaddockProgram` option).
 113   ''
 114     HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"}
 115     # Build haddocks for boot packages with hyperlinking
 116     EXTRA_HADDOCK_OPTS += --hyperlinked-source --quickjump
 117
 118     DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
 119     INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
 120   '' + lib.optionalString (targetPlatform != hostPlatform) ''
 121     Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
 122     CrossCompilePrefix = ${targetPrefix}
 123   '' + lib.optionalString (!enableProfiledLibs) ''
 124     BUILD_PROF_LIBS = NO
 125   '' + lib.optionalString enableRelocatedStaticLibs ''
 126     GhcLibHcOpts += -fPIC
 127     GhcRtsHcOpts += -fPIC
 128   '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
 129     EXTRA_CC_OPTS += -std=gnu99
 130   ''
 131   # While split sections are now enabled by default in ghc 8.8 for windows,
 132   # they seem to lead to `too many sections` errors when building base for
 133   # profiling.
 134   + lib.optionalString targetPlatform.isWindows ''
 135     SplitSections = NO
 136   '';
 137
 138   # Splicer will pull out correct variations
 139   libDeps = platform: lib.optional enableTerminfo ncurses
 140     ++ [args.${libffi_name}]
 141     ++ lib.optional (!enableIntegerSimple) gmp
 142     ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
 143
 144   # TODO(@sternenseemann): is buildTarget LLVM unnecessary?
 145   # GHC doesn't seem to have {LLC,OPT}_HOST
 146   toolsForTarget = [
 147     pkgsBuildTarget.targetPackages.stdenv.cc
 148   ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm;
 149
 150   buildCC = buildPackages.stdenv.cc;
 151   targetCC = builtins.head toolsForTarget;
 152   installCC = pkgsHostTarget.targetPackages.stdenv.cc;
 153
 154   # toolPath calculates the absolute path to the name tool associated with a
 155   # given `stdenv.cc` derivation, i.e. it picks the correct derivation to take
 156   # the tool from (cc, cc.bintools, cc.bintools.bintools) and adds the correct
 157   # subpath of the tool.
 158   toolPath = name: cc:
 159     let
 160       tools = {
 161         "cc" = cc;
 162         "c++" = cc;
 163         as = cc.bintools;
 164
 165         ar = cc.bintools;
 166         ranlib = cc.bintools;
 167         nm = cc.bintools;
 168         readelf = cc.bintools;
 169         objdump = cc.bintools;
 170
 171         ld = cc.bintools;
 172         "ld.gold" = cc.bintools;
 173
 174         otool = cc.bintools.bintools;
 175
 176         # GHC needs install_name_tool on all darwin platforms. The same one can
 177         # be used on both platforms. It is safe to use with linker-generated
 178         # signatures because it will update the signatures automatically after
 179         # modifying the target binary.
 180         install_name_tool = cc.bintools.bintools;
 181
 182         # strip on darwin is wrapped to enable deterministic mode.
 183         strip =
 184           # TODO(@sternenseemann): also use wrapper if linker == "bfd" or "gold"
 185           if stdenv.targetPlatform.isDarwin
 186           then cc.bintools
 187           else cc.bintools.bintools;
 188
 189         # clang is used as an assembler on darwin with the LLVM backend
 190         clang = cc;
 191       }.${name};
 192     in
 193     "${tools}/bin/${tools.targetPrefix}${name}";
 194
 195   # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.
 196   # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
 197   # see #84670 and #49071 for more background.
 198   useLdGold = targetPlatform.linker == "gold" ||
 199     (targetPlatform.linker == "bfd" && (targetCC.bintools.bintools.hasGold or false) && !targetPlatform.isMusl);
 200
 201   # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
 202   variantSuffix = lib.concatStrings [
 203     (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
 204     (lib.optionalString enableIntegerSimple "-integer-simple")
 205   ];
 206
 207   libffi_name =
 208     if stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64
 209     then "libffi"
 210     else "libffi_3_3";
 211
 212   # These libraries are library dependencies of the standard libraries bundled
 213   # by GHC (core libs) users will link their compiled artifacts again. Thus,
 214   # they should be taken from targetPackages.
 215   #
 216   # We need to use pkgsHostTarget if we are cross compiling a native GHC compiler,
 217   # though (when native compiling GHC, pkgsHostTarget == targetPackages):
 218   #
 219   # 1. targetPackages would be empty(-ish) in this situation since we can't
 220   #    execute cross compiled compilers in order to obtain the libraries
 221   #    that would be in targetPackages.
 222   # 2. pkgsHostTarget is fine to use since hostPlatform == targetPlatform in this
 223   #    situation.
 224   # 3. The core libs used by the final GHC (stage 2) for user artifacts are also
 225   #    used to build stage 2 GHC itself, i.e. the core libs are both host and
 226   #    target.
 227   targetLibs =
 228     let
 229       basePackageSet =
 230         if hostPlatform != targetPlatform
 231         then targetPackages
 232         else pkgsHostTarget;
 233     in
 234       {
 235         inherit (basePackageSet) gmp ncurses;
 236         # dynamic inherits are not possible in Nix
 237         libffi = basePackageSet.${libffi_name};
 238       };
 239
 240 in
 241
 242 stdenv.mkDerivation (rec {
 243   version = "8.10.7";
 244   pname = "${targetPrefix}ghc${variantSuffix}";
 245
 246   src = fetchurl {
 247     url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
 248     sha256 = "e3eef6229ce9908dfe1ea41436befb0455fefb1932559e860ad4c606b0d03c9d";
 249   };
 250
 251   enableParallelBuilding = true;
 252
 253   outputs = [ "out" "doc" ];
 254
 255   patches = [
 256     # Fix docs build with sphinx >= 6.0
 257     # https://gitlab.haskell.org/ghc/ghc/-/issues/22766
 258     (fetchpatch {
 259       name = "ghc-docs-sphinx-6.0.patch";
 260       url = "https://gitlab.haskell.org/ghc/ghc/-/commit/10e94a556b4f90769b7fd718b9790d58ae566600.patch";
 261       sha256 = "0kmhfamr16w8gch0lgln2912r8aryjky1hfcda3jkcwa5cdzgjdv";
 262     })
 263
 264     # See upstream patch at
 265     # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4885. Since we build
 266     # from source distributions, the auto-generated configure script needs to be
 267     # patched as well, therefore we use an in-tree patch instead of pulling the
 268     # upstream patch. Don't forget to check backport status of the upstream patch
 269     # when adding new GHC releases in nixpkgs.
 270     ./respect-ar-path.patch
 271
 272     # fix hyperlinked haddock sources: https://github.com/haskell/haddock/pull/1482
 273     (fetchpatch {
 274       url = "https://patch-diff.githubusercontent.com/raw/haskell/haddock/pull/1482.patch";
 275       sha256 = "sha256-8w8QUCsODaTvknCDGgTfFNZa8ZmvIKaKS+2ZJZ9foYk=";
 276       extraPrefix = "utils/haddock/";
 277       stripLen = 1;
 278     })
 279
 280     # cabal passes incorrect --host= when cross-compiling
 281     # https://github.com/haskell/cabal/issues/5887
 282     (fetchpatch {
 283             url = "https://raw.githubusercontent.com/input-output-hk/haskell.nix/122bd81150386867da07fdc9ad5096db6719545a/overlays/patches/ghc/cabal-host.patch";
 284       sha256 = "sha256:0yd0sajgi24sc1w5m55lkg2lp6kfkgpp3lgija2c8y3cmkwfpdc1";
 285     })
 286
 287     # In order to build ghcjs packages, the Cabal of the ghc used for the ghcjs
 288     # needs to be patched. Ref https://github.com/haskell/cabal/pull/7575
 289     (fetchpatch {
 290       url = "https://github.com/haskell/cabal/commit/369c4a0a54ad08a9e6b0d3bd303fedd7b5e5a336.patch";
 291       sha256 = "120f11hwyaqa0pq9g5l1300crqij49jg0rh83hnp9sa49zfdwx1n";
 292       stripLen = 3;
 293       extraPrefix = "libraries/Cabal/Cabal/";
 294     })
 295
 296     # We need to be able to set AR_STAGE0 and LD_STAGE0 when cross-compiling
 297     (fetchpatch {
 298       url = "https://gitlab.haskell.org/ghc/ghc/-/commit/8f7dd5710b80906ea7a3e15b7bb56a883a49fed8.patch";
 299       hash = "sha256-C636Nq2U8YOG/av7XQmG3L1rU0bmC9/7m7Hty5pm5+s=";
 300     })
 301
 302     # Backport part of <https://gitlab.haskell.org/ghc/ghc/-/merge_requests/7111> to 8.10.7
 303     # The change we are interested in is that Cabal no longer sets include-dirs
 304     # for the GHCi library delegating to the system search path or (in our case)
 305     # cc-wrapper. Without this patch, the target libffi ends up in there (which
 306     # we provide via --with-ffi-includes) which breaks bootstrapping e.g. when
 307     # cross compiling GHC. Without include-dirs, cc-wrapper and splicing will
 308     # correctly pick the suitable libffi out of the build environment.
 309     (fetchpatch {
 310       name = "ghci-no-libffi-include.patch";
 311       url = "https://gitlab.haskell.org/ghc/ghc/-/commit/b2721819f391ab49871271283f32df54810c4387.patch";
 312       sha256 = "1rmv3132xhxbka97v0rx7r6larx5f5nnvs4mgm9q3rmgpjyd1vf9";
 313       includes = [ "libraries/ghci/ghci.cabal.in" ];
 314     })
 315   ] ++ lib.optionals stdenv.hostPlatform.isDarwin [
 316     # Make Block.h compile with c++ compilers. Remove with the next release
 317     (fetchpatch {
 318       url = "https://gitlab.haskell.org/ghc/ghc/-/commit/97d0b0a367e4c6a52a17c3299439ac7de129da24.patch";
 319       sha256 = "0r4zjj0bv1x1m2dgxp3adsf2xkr94fjnyj1igsivd9ilbs5ja0b5";
 320     })
 321   ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [
 322     # Prevent the paths module from emitting symbols that we don't use
 323     # when building with separate outputs.
 324     #
 325     # These cause problems as they're not eliminated by GHC's dead code
 326     # elimination on aarch64-darwin. (see
 327     # https://github.com/NixOS/nixpkgs/issues/140774 for details).
 328     ./Cabal-3.2-3.4-paths-fix-cycle-aarch64-darwin.patch
 329   ];
 330
 331   postPatch = "patchShebangs .";
 332
 333   # GHC is a bit confused on its cross terminology.
 334   # TODO(@sternenseemann): investigate coreutils dependencies and pass absolute paths
 335   preConfigure = ''
 336     for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
 337       export "''${env#TARGET_}=''${!env}"
 338     done
 339     # Stage0 (build->build) which builds stage 1
 340     export GHC="${bootPkgs.ghc}/bin/ghc"
 341     # GHC is a bit confused on its cross terminology, as these would normally be
 342     # the *host* tools.
 343     export CC="${toolPath "cc" targetCC}"
 344     export CXX="${toolPath "c++" targetCC}"
 345     # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
 346     export LD="${toolPath "ld${lib.optionalString useLdGold ".gold"}" targetCC}"
 347     export AS="${toolPath "as" targetCC}"
 348     export AR="${toolPath "ar" targetCC}"
 349     export NM="${toolPath "nm" targetCC}"
 350     export RANLIB="${toolPath "ranlib" targetCC}"
 351     export READELF="${toolPath "readelf" targetCC}"
 352     export STRIP="${toolPath "strip" targetCC}"
 353     export OBJDUMP="${toolPath "objdump" targetCC}"
 354   '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") ''
 355     export OTOOL="${toolPath "otool" targetCC}"
 356     export INSTALL_NAME_TOOL="${toolPath "install_name_tool" targetCC}"
 357   '' + lib.optionalString useLLVM ''
 358     export LLC="${lib.getBin buildTargetLlvmPackages.llvm}/bin/llc"
 359     export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt"
 360   '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) ''
 361     # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm
 362     # The executable we specify via $CLANG is used as an assembler (exclusively, it seems, but this isn't
 363     # clarified in any user facing documentation). As such, it'll be called on assembly produced by $CC
 364     # which usually comes from the darwin stdenv. To prevent a situation where $CLANG doesn't understand
 365     # the assembly it is given, we need to make sure that it matches the LLVM version of $CC if possible.
 366     # It is unclear (at the time of writing 2024-09-01)  whether $CC should match the LLVM version we use
 367     # for llc and opt which would require using a custom darwin stdenv for targetCC.
 368     export CLANG="${
 369       if targetCC.isClang
 370       then toolPath "clang" targetCC
 371       else "${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang"
 372     }"
 373   '' + ''
 374     # No need for absolute paths since these tools only need to work during the build
 375     export CC_STAGE0="$CC_FOR_BUILD"
 376     export LD_STAGE0="$LD_FOR_BUILD"
 377     export AR_STAGE0="$AR_FOR_BUILD"
 378
 379     echo -n "${buildMK}" > mk/build.mk
 380     sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
 381   '' + lib.optionalString (!stdenv.hostPlatform.isDarwin) ''
 382     export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
 383   '' + lib.optionalString stdenv.hostPlatform.isDarwin ''
 384     export NIX_LDFLAGS+=" -no_dtrace_dof"
 385
 386     # GHC tries the host xattr /usr/bin/xattr by default which fails since it expects python to be 2.7
 387     export XATTR=${lib.getBin xattr}/bin/xattr
 388   '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
 389     sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
 390   '' + lib.optionalString targetPlatform.isMusl ''
 391       echo "patching llvm-targets for musl targets..."
 392       echo "Cloning these existing '*-linux-gnu*' targets:"
 393       grep linux-gnu llvm-targets | sed 's/^/  /'
 394       echo "(go go gadget sed)"
 395       sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
 396       echo "llvm-targets now contains these '*-linux-musl*' targets:"
 397       grep linux-musl llvm-targets | sed 's/^/  /'
 398
 399       echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
 400       # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
 401       for x in configure aclocal.m4; do
 402         substituteInPlace $x \
 403           --replace '*-android*|*-gnueabi*)' \
 404                     '*-android*|*-gnueabi*|*-musleabi*)'
 405       done
 406   '';
 407
 408   # Although it is usually correct to pass --host, we don't do that here because
 409   # GHC's usage of build, host, and target is non-standard.
 410   # See https://gitlab.haskell.org/ghc/ghc/-/wikis/building/cross-compiling
 411   # TODO(@Ericson2314): Always pass "--target" and always prefix.
 412   configurePlatforms = [ "build" ]
 413     ++ lib.optional (buildPlatform != hostPlatform || targetPlatform != hostPlatform) "target";
 414
 415   # `--with` flags for libraries needed for RTS linker
 416   configureFlags = [
 417     "--datadir=$doc/share/doc/ghc"
 418   ] ++ lib.optionals enableTerminfo [
 419     "--with-curses-includes=${lib.getDev targetLibs.ncurses}/include"
 420     "--with-curses-libraries=${lib.getLib targetLibs.ncurses}/lib"
 421   ] ++ lib.optionals (args.${libffi_name} != null) [
 422     "--with-system-libffi"
 423     "--with-ffi-includes=${targetLibs.libffi.dev}/include"
 424     "--with-ffi-libraries=${targetLibs.libffi.out}/lib"
 425   ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
 426     "--with-gmp-includes=${targetLibs.gmp.dev}/include"
 427     "--with-gmp-libraries=${targetLibs.gmp.out}/lib"
 428   ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
 429     "--with-iconv-includes=${libiconv}/include"
 430     "--with-iconv-libraries=${libiconv}/lib"
 431   ] ++ lib.optionals (targetPlatform != hostPlatform) [
 432     "--enable-bootstrap-with-devel-snapshot"
 433   ] ++ lib.optionals useLdGold [
 434     "CFLAGS=-fuse-ld=gold"
 435     "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
 436     "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
 437   ] ++ lib.optionals (disableLargeAddressSpace) [
 438     "--disable-large-address-space"
 439   ] ++ lib.optionals enableUnregisterised [
 440     "--enable-unregisterised"
 441   ];
 442
 443   # Make sure we never relax`$PATH` and hooks support for compatibility.
 444   strictDeps = true;
 445
 446   # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
 447   dontAddExtraLibs = true;
 448
 449   nativeBuildInputs = [
 450     perl autoreconfHook autoconf automake m4 python3
 451     bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
 452     bootPkgs.ghc-settings-edit
 453   ] ++ lib.optionals (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64) [
 454     autoSignDarwinBinariesHook
 455   ] ++ lib.optionals enableDocs [
 456     sphinx
 457   ];
 458
 459   # Everything the stage0 compiler needs to build stage1: CC, bintools, extra libs.
 460   # See also GHC, {CC,LD,AR}_STAGE0 in preConfigure.
 461   depsBuildBuild = [
 462     # N.B. We do not declare bootPkgs.ghc in any of the stdenv.mkDerivation
 463     # dependency lists to prevent the bintools setup hook from adding ghc's
 464     # lib directory to the linker flags. Instead we tell configure about it
 465     # via the GHC environment variable.
 466     buildCC
 467     # stage0 builds terminfo unconditionally, so we always need ncurses
 468     ncurses
 469   ];
 470   # For building runtime libs
 471   depsBuildTarget = toolsForTarget;
 472
 473   # Prevent stage0 ghc from leaking into the final result. This was an issue
 474   # with GHC 9.6.
 475   disallowedReferences = [
 476     bootPkgs.ghc
 477   ];
 478
 479   buildInputs = [ bash ] ++ (libDeps hostPlatform);
 480
 481   depsTargetTarget = map lib.getDev (libDeps targetPlatform);
 482   depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
 483
 484   # required, because otherwise all symbols from HSffi.o are stripped, and
 485   # that in turn causes GHCi to abort
 486   stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
 487
 488   checkTarget = "test";
 489
 490   hardeningDisable =
 491     [ "format" ]
 492     # In nixpkgs, musl based builds currently enable `pie` hardening by default
 493     # (see `defaultHardeningFlags` in `make-derivation.nix`).
 494     # But GHC cannot currently produce outputs that are ready for `-pie` linking.
 495     # Thus, disable `pie` hardening, otherwise `recompile with -fPIE` errors appear.
 496     # See:
 497     # * https://github.com/NixOS/nixpkgs/issues/129247
 498     # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580
 499     ++ lib.optional stdenv.targetPlatform.isMusl "pie";
 500
 501   # big-parallel allows us to build with more than 2 cores on
 502   # Hydra which already warrants a significant speedup
 503   requiredSystemFeatures = [ "big-parallel" ];
 504
 505   postInstall = ''
 506     settingsFile="$out/lib/${targetPrefix}${passthru.haskellCompilerName}/settings"
 507
 508     # Make the installed GHC use the host->target tools.
 509     ghc-settings-edit "$settingsFile" \
 510       "C compiler command" "${toolPath "cc" installCC}" \
 511       "Haskell CPP command" "${toolPath "cc" installCC}" \
 512       "C++ compiler command" "${toolPath "c++" installCC}" \
 513       "ld command" "${toolPath "ld${lib.optionalString useLdGold ".gold"}" installCC}" \
 514       "Merge objects command" "${toolPath "ld${lib.optionalString useLdGold ".gold"}" installCC}" \
 515       "ar command" "${toolPath "ar" installCC}" \
 516       "ranlib command" "${toolPath "ranlib" installCC}"
 517   ''
 518   + lib.optionalString (stdenv.targetPlatform.linker == "cctools") ''
 519     ghc-settings-edit "$settingsFile" \
 520       "otool command" "${toolPath "otool" installCC}" \
 521       "install_name_tool command" "${toolPath "install_name_tool" installCC}"
 522   ''
 523   + lib.optionalString useLLVM ''
 524     ghc-settings-edit "$settingsFile" \
 525       "LLVM llc command" "${lib.getBin llvmPackages.llvm}/bin/llc" \
 526       "LLVM opt command" "${lib.getBin llvmPackages.llvm}/bin/opt"
 527   ''
 528   + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) ''
 529     ghc-settings-edit "$settingsFile" \
 530       "LLVM clang command" "${
 531         # See comment for CLANG in preConfigure
 532         if installCC.isClang
 533         then toolPath "clang" installCC
 534         else "${llvmPackages.clang}/bin/${llvmPackages.clang.targetPrefix}clang"
 535       }"
 536   ''
 537   + ''
 538
 539     # Install the bash completion file.
 540     install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
 541   '';
 542
 543   passthru = {
 544     inherit bootPkgs targetPrefix;
 545
 546     inherit llvmPackages;
 547     inherit enableShared;
 548
 549     # This is used by the haskell builder to query
 550     # the presence of the haddock program.
 551     hasHaddock = enableHaddockProgram;
 552
 553     # Our Cabal compiler name
 554     haskellCompilerName = "ghc-${version}";
 555   };
 556
 557   meta = {
 558     homepage = "http://haskell.org/ghc";
 559     description = "Glasgow Haskell Compiler";
 560     maintainers = with lib.maintainers; [
 561       guibou
 562     ] ++ lib.teams.haskell.members;
 563     timeout = 24 * 3600;
 564     platforms = lib.platforms.all;
 565     inherit (bootPkgs.ghc.meta) license;
 566   };
 567
 568 } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {
 569   dontStrip = true;
 570   dontPatchELF = true;
 571   noAuditTmpdir = true;
 572 })