haskellPackages.ghc: 9.4.7 -> 9.4.8

haskell.compiler.ghc94: 9.4.7 -> 9.4.8
haskell.compiler.ghc948: init at 9.4.8

https://www.haskell.org/ghc/blog/20231110-ghc-9.4.8-released.html

+424 -2
+391
pkgs/development/compilers/ghc/9.4.8.nix
··· 1 + # DO NOT port this expression to hadrian. It is not possible to build a GHC 2 + # cross compiler with 9.4.* and hadrian. 3 + { lib, stdenv, pkgsBuildTarget, pkgsHostTarget, targetPackages 4 + 5 + # build-tools 6 + , bootPkgs 7 + , autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx 8 + , xattr, autoSignDarwinBinariesHook 9 + , bash 10 + 11 + , libiconv ? null, ncurses 12 + , glibcLocales ? null 13 + 14 + , # GHC can be built with system libffi or a bundled one. 15 + libffi ? null 16 + 17 + , useLLVM ? !(stdenv.targetPlatform.isx86 18 + || stdenv.targetPlatform.isPower 19 + || stdenv.targetPlatform.isSparc 20 + || stdenv.targetPlatform.isAarch64) 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 slightly slower native 27 + # bignum backend instead of the faster but GPLed gmp backend. 28 + enableNativeBignum ? !(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 + , enableProfiledLibs ? true 36 + 37 + , # Whether to build dynamic libs for the standard library (on the target 38 + # platform). Static libs are always built. 39 + enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic 40 + 41 + , # Whether to build terminfo. 42 + enableTerminfo ? !stdenv.targetPlatform.isWindows 43 + 44 + , # What flavour to build. An empty string indicates no 45 + # specific flavour and falls back to ghc default values. 46 + ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform) 47 + (if useLLVM then "perf-cross" else "perf-cross-ncg") 48 + 49 + , # Whether to build sphinx documentation. 50 + enableDocs ? ( 51 + # Docs disabled for musl and cross because it's a large task to keep 52 + # all `sphinx` dependencies building in those environments. 53 + # `sphinx` pulls in among others: 54 + # Ruby, Python, Perl, Rust, OpenGL, Xorg, gtk, LLVM. 55 + (stdenv.targetPlatform == stdenv.hostPlatform) 56 + && !stdenv.hostPlatform.isMusl 57 + ) 58 + 59 + , enableHaddockProgram ? 60 + # Disabled for cross; see note [HADDOCK_DOCS]. 61 + (stdenv.targetPlatform == stdenv.hostPlatform) 62 + 63 + , # Whether to disable the large address space allocator 64 + # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/ 65 + disableLargeAddressSpace ? stdenv.targetPlatform.isiOS 66 + }: 67 + 68 + assert !enableNativeBignum -> gmp != null; 69 + 70 + # Cross cannot currently build the `haddock` program for silly reasons, 71 + # see note [HADDOCK_DOCS]. 72 + assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram; 73 + 74 + let 75 + inherit (stdenv) buildPlatform hostPlatform targetPlatform; 76 + 77 + inherit (bootPkgs) ghc; 78 + 79 + # TODO(@Ericson2314) Make unconditional 80 + targetPrefix = lib.optionalString 81 + (targetPlatform != hostPlatform) 82 + "${targetPlatform.config}-"; 83 + 84 + buildMK = '' 85 + BuildFlavour = ${ghcFlavour} 86 + ifneq \"\$(BuildFlavour)\" \"\" 87 + include mk/flavours/\$(BuildFlavour).mk 88 + endif 89 + BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"} 90 + BUILD_SPHINX_PDF = NO 91 + '' + 92 + # Note [HADDOCK_DOCS]: 93 + # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock` 94 + # program is built (which we generally always want to have a complete GHC install) 95 + # and whether it is run on the GHC sources to generate hyperlinked source code 96 + # (which is impossible for cross-compilation); see: 97 + # https://gitlab.haskell.org/ghc/ghc/-/issues/20077 98 + # This implies that currently a cross-compiled GHC will never have a `haddock` 99 + # program, so it can never generate haddocks for any packages. 100 + # If this is solved in the future, we'd like to unconditionally 101 + # build the haddock program (removing the `enableHaddockProgram` option). 102 + '' 103 + HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"} 104 + # Build haddocks for boot packages with hyperlinking 105 + EXTRA_HADDOCK_OPTS += --hyperlinked-source --quickjump 106 + 107 + DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"} 108 + BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"} 109 + '' + lib.optionalString (targetPlatform != hostPlatform) '' 110 + Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"} 111 + CrossCompilePrefix = ${targetPrefix} 112 + '' + lib.optionalString (!enableProfiledLibs) '' 113 + GhcLibWays = "v dyn" 114 + '' + 115 + # -fexternal-dynamic-refs apparently (because it's not clear from the documentation) 116 + # makes the GHC RTS able to load static libraries, which may be needed for TemplateHaskell. 117 + # This solution was described in https://www.tweag.io/blog/2020-09-30-bazel-static-haskell 118 + lib.optionalString enableRelocatedStaticLibs '' 119 + GhcLibHcOpts += -fPIC -fexternal-dynamic-refs 120 + GhcRtsHcOpts += -fPIC -fexternal-dynamic-refs 121 + '' + lib.optionalString targetPlatform.useAndroidPrebuilt '' 122 + EXTRA_CC_OPTS += -std=gnu99 123 + ''; 124 + 125 + # Splicer will pull out correct variations 126 + libDeps = platform: lib.optional enableTerminfo ncurses 127 + ++ [libffi] 128 + ++ lib.optional (!enableNativeBignum) gmp 129 + ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv; 130 + 131 + # TODO(@sternenseemann): is buildTarget LLVM unnecessary? 132 + # GHC doesn't seem to have {LLC,OPT}_HOST 133 + toolsForTarget = [ 134 + pkgsBuildTarget.targetPackages.stdenv.cc 135 + ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm; 136 + 137 + targetCC = builtins.head toolsForTarget; 138 + 139 + # Sometimes we have to dispatch between the bintools wrapper and the unwrapped 140 + # derivation for certain tools depending on the platform. 141 + bintoolsFor = { 142 + # GHC needs install_name_tool on all darwin platforms. On aarch64-darwin it is 143 + # part of the bintools wrapper (due to codesigning requirements), but not on 144 + # x86_64-darwin. 145 + install_name_tool = 146 + if stdenv.targetPlatform.isAarch64 147 + then targetCC.bintools 148 + else targetCC.bintools.bintools; 149 + # Same goes for strip. 150 + strip = 151 + # TODO(@sternenseemann): also use wrapper if linker == "bfd" or "gold" 152 + if stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin 153 + then targetCC.bintools 154 + else targetCC.bintools.bintools; 155 + }; 156 + 157 + # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues. 158 + # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856 159 + # see #84670 and #49071 for more background. 160 + useLdGold = targetPlatform.linker == "gold" || 161 + (targetPlatform.linker == "bfd" && (targetCC.bintools.bintools.hasGold or false) && !targetPlatform.isMusl); 162 + 163 + # Makes debugging easier to see which variant is at play in `nix-store -q --tree`. 164 + variantSuffix = lib.concatStrings [ 165 + (lib.optionalString stdenv.hostPlatform.isMusl "-musl") 166 + (lib.optionalString enableNativeBignum "-native-bignum") 167 + ]; 168 + 169 + in 170 + 171 + # C compiler, bintools and LLVM are used at build time, but will also leak into 172 + # the resulting GHC's settings file and used at runtime. This means that we are 173 + # currently only able to build GHC if hostPlatform == buildPlatform. 174 + assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc; 175 + assert buildTargetLlvmPackages.llvm == llvmPackages.llvm; 176 + assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang; 177 + 178 + stdenv.mkDerivation (rec { 179 + version = "9.4.8"; 180 + pname = "${targetPrefix}ghc${variantSuffix}"; 181 + 182 + src = fetchurl { 183 + url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz"; 184 + sha256 = "0bf407eb67fe3e3c24b0f4c8dea8cb63e07f63ca0f76cf2058565143507ab85e"; 185 + }; 186 + 187 + enableParallelBuilding = true; 188 + 189 + outputs = [ "out" "doc" ]; 190 + 191 + patches = [ 192 + # Don't generate code that doesn't compile when --enable-relocatable is passed to Setup.hs 193 + # Can be removed if the Cabal library included with ghc backports the linked fix 194 + (fetchpatch { 195 + url = "https://github.com/haskell/cabal/commit/6c796218c92f93c95e94d5ec2d077f6956f68e98.patch"; 196 + stripLen = 1; 197 + extraPrefix = "libraries/Cabal/"; 198 + sha256 = "sha256-yRQ6YmMiwBwiYseC5BsrEtDgFbWvst+maGgDtdD0vAY="; 199 + }) 200 + 201 + # Fix docs build with Sphinx >= 7 https://gitlab.haskell.org/ghc/ghc/-/issues/24129 202 + ./docs-sphinx-7.patch 203 + ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [ 204 + # Prevent the paths module from emitting symbols that we don't use 205 + # when building with separate outputs. 206 + # 207 + # These cause problems as they're not eliminated by GHC's dead code 208 + # elimination on aarch64-darwin. (see 209 + # https://github.com/NixOS/nixpkgs/issues/140774 for details). 210 + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch 211 + ]; 212 + 213 + postPatch = "patchShebangs ."; 214 + 215 + # GHC needs the locale configured during the Haddock phase. 216 + LANG = "en_US.UTF-8"; 217 + 218 + # GHC is a bit confused on its cross terminology. 219 + # TODO(@sternenseemann): investigate coreutils dependencies and pass absolute paths 220 + preConfigure = '' 221 + for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do 222 + export "''${env#TARGET_}=''${!env}" 223 + done 224 + # GHC is a bit confused on its cross terminology, as these would normally be 225 + # the *host* tools. 226 + export CC="${targetCC}/bin/${targetCC.targetPrefix}cc" 227 + export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++" 228 + # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177 229 + export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}" 230 + export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as" 231 + export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar" 232 + export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm" 233 + export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib" 234 + export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf" 235 + export STRIP="${bintoolsFor.strip}/bin/${bintoolsFor.strip.targetPrefix}strip" 236 + '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") '' 237 + export OTOOL="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}otool" 238 + export INSTALL_NAME_TOOL="${bintoolsFor.install_name_tool}/bin/${bintoolsFor.install_name_tool.targetPrefix}install_name_tool" 239 + '' + lib.optionalString useLLVM '' 240 + export LLC="${lib.getBin buildTargetLlvmPackages.llvm}/bin/llc" 241 + export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt" 242 + '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) '' 243 + # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm 244 + export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang" 245 + '' + '' 246 + 247 + echo -n "${buildMK}" > mk/build.mk 248 + 249 + sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure 250 + '' + lib.optionalString (stdenv.isLinux && hostPlatform.libc == "glibc") '' 251 + export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive" 252 + '' + lib.optionalString (!stdenv.isDarwin) '' 253 + export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}" 254 + '' + lib.optionalString stdenv.isDarwin '' 255 + export NIX_LDFLAGS+=" -no_dtrace_dof" 256 + 257 + # GHC tries the host xattr /usr/bin/xattr by default which fails since it expects python to be 2.7 258 + export XATTR=${lib.getBin xattr}/bin/xattr 259 + '' + lib.optionalString targetPlatform.useAndroidPrebuilt '' 260 + 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 261 + '' + lib.optionalString targetPlatform.isMusl '' 262 + echo "patching llvm-targets for musl targets..." 263 + echo "Cloning these existing '*-linux-gnu*' targets:" 264 + grep linux-gnu llvm-targets | sed 's/^/ /' 265 + echo "(go go gadget sed)" 266 + sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets 267 + echo "llvm-targets now contains these '*-linux-musl*' targets:" 268 + grep linux-musl llvm-targets | sed 's/^/ /' 269 + 270 + echo "And now patching to preserve '-musleabi' as done with '-gnueabi'" 271 + # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen) 272 + for x in configure aclocal.m4; do 273 + substituteInPlace $x \ 274 + --replace '*-android*|*-gnueabi*)' \ 275 + '*-android*|*-gnueabi*|*-musleabi*)' 276 + done 277 + '' 278 + # HACK: allow bootstrapping with GHC 8.10 which works fine, as we don't have 279 + # binary 9.0 packaged. Bootstrapping with 9.2 is broken without hadrian. 280 + + '' 281 + substituteInPlace configure --replace \ 282 + 'MinBootGhcVersion="9.0"' \ 283 + 'MinBootGhcVersion="8.10"' 284 + ''; 285 + 286 + # TODO(@Ericson2314): Always pass "--target" and always prefix. 287 + configurePlatforms = [ "build" "host" ] 288 + ++ lib.optional (targetPlatform != hostPlatform) "target"; 289 + 290 + # `--with` flags for libraries needed for RTS linker 291 + configureFlags = [ 292 + "--datadir=$doc/share/doc/ghc" 293 + "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib" 294 + ] ++ lib.optionals (libffi != null) [ 295 + "--with-system-libffi" 296 + "--with-ffi-includes=${targetPackages.libffi.dev}/include" 297 + "--with-ffi-libraries=${targetPackages.libffi.out}/lib" 298 + ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [ 299 + "--with-gmp-includes=${targetPackages.gmp.dev}/include" 300 + "--with-gmp-libraries=${targetPackages.gmp.out}/lib" 301 + ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [ 302 + "--with-iconv-includes=${libiconv}/include" 303 + "--with-iconv-libraries=${libiconv}/lib" 304 + ] ++ lib.optionals (targetPlatform != hostPlatform) [ 305 + "--enable-bootstrap-with-devel-snapshot" 306 + ] ++ lib.optionals useLdGold [ 307 + "CFLAGS=-fuse-ld=gold" 308 + "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold" 309 + "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold" 310 + ] ++ lib.optionals (disableLargeAddressSpace) [ 311 + "--disable-large-address-space" 312 + ]; 313 + 314 + # Make sure we never relax`$PATH` and hooks support for compatibility. 315 + strictDeps = true; 316 + 317 + # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself. 318 + dontAddExtraLibs = true; 319 + 320 + nativeBuildInputs = [ 321 + perl autoconf automake m4 python3 322 + ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour 323 + ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [ 324 + autoSignDarwinBinariesHook 325 + ] ++ lib.optionals enableDocs [ 326 + sphinx 327 + ]; 328 + 329 + # For building runtime libs 330 + depsBuildTarget = toolsForTarget; 331 + 332 + buildInputs = [ perl bash ] ++ (libDeps hostPlatform); 333 + 334 + depsTargetTarget = map lib.getDev (libDeps targetPlatform); 335 + depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform); 336 + 337 + # required, because otherwise all symbols from HSffi.o are stripped, and 338 + # that in turn causes GHCi to abort 339 + stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols"; 340 + 341 + checkTarget = "test"; 342 + 343 + hardeningDisable = 344 + [ "format" ] 345 + # In nixpkgs, musl based builds currently enable `pie` hardening by default 346 + # (see `defaultHardeningFlags` in `make-derivation.nix`). 347 + # But GHC cannot currently produce outputs that are ready for `-pie` linking. 348 + # Thus, disable `pie` hardening, otherwise `recompile with -fPIE` errors appear. 349 + # See: 350 + # * https://github.com/NixOS/nixpkgs/issues/129247 351 + # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580 352 + ++ lib.optional stdenv.targetPlatform.isMusl "pie"; 353 + 354 + # big-parallel allows us to build with more than 2 cores on 355 + # Hydra which already warrants a significant speedup 356 + requiredSystemFeatures = [ "big-parallel" ]; 357 + 358 + postInstall = '' 359 + # Install the bash completion file. 360 + install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc 361 + ''; 362 + 363 + passthru = { 364 + inherit bootPkgs targetPrefix; 365 + 366 + inherit llvmPackages; 367 + inherit enableShared; 368 + 369 + # This is used by the haskell builder to query 370 + # the presence of the haddock program. 371 + hasHaddock = enableHaddockProgram; 372 + 373 + # Our Cabal compiler name 374 + haskellCompilerName = "ghc-${version}"; 375 + }; 376 + 377 + meta = { 378 + homepage = "http://haskell.org/ghc"; 379 + description = "The Glasgow Haskell Compiler"; 380 + maintainers = with lib.maintainers; [ 381 + guibou 382 + ] ++ lib.teams.haskell.members; 383 + timeout = 24 * 3600; 384 + inherit (ghc.meta) license platforms; 385 + }; 386 + 387 + } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt { 388 + dontStrip = true; 389 + dontPatchELF = true; 390 + noAuditTmpdir = true; 391 + })
+33 -2
pkgs/top-level/haskell-packages.nix
··· 25 25 "ghc945" 26 26 "ghc946" 27 27 "ghc947" 28 + "ghc948" 28 29 "ghc94" 29 30 "ghc96" 30 31 "ghc962" ··· 50 51 "ghc945" 51 52 "ghc946" 52 53 "ghc947" 54 + "ghc948" 53 55 "ghc96" 54 56 "ghc962" 55 57 "ghc963" ··· 363 365 buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12; 364 366 llvmPackages = pkgs.llvmPackages_12; 365 367 }; 366 - ghc94 = compiler.ghc947; 368 + ghc948 = callPackage ../development/compilers/ghc/9.4.8.nix { 369 + bootPkgs = 370 + # Building with 9.2 is broken due to 371 + # https://gitlab.haskell.org/ghc/ghc/-/issues/21914 372 + # Use 8.10 as a workaround where possible to keep bootstrap path short. 373 + 374 + # On ARM text won't build with GHC 8.10.* 375 + if stdenv.hostPlatform.isAarch then 376 + # TODO(@sternenseemann): package bindist 377 + packages.ghc902 378 + # No suitable bindists for powerpc64le 379 + else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then 380 + packages.ghc902 381 + else 382 + packages.ghc8107Binary; 383 + inherit (buildPackages.python3Packages) sphinx; 384 + # Need to use apple's patched xattr until 385 + # https://github.com/xattr/xattr/issues/44 and 386 + # https://github.com/xattr/xattr/issues/55 are solved. 387 + inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook; 388 + # Support range >= 10 && < 14 389 + buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12; 390 + llvmPackages = pkgs.llvmPackages_12; 391 + }; 392 + ghc94 = compiler.ghc948; 367 393 ghc962 = callPackage ../development/compilers/ghc/9.6.2.nix { 368 394 bootPkgs = 369 395 # For GHC 9.2 no armv7l bindists are available. ··· 558 584 ghc = bh.compiler.ghc947; 559 585 compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.4.x.nix { }; 560 586 }; 561 - ghc94 = packages.ghc947; 587 + ghc948 = callPackage ../development/haskell-modules { 588 + buildHaskellPackages = bh.packages.ghc948; 589 + ghc = bh.compiler.ghc948; 590 + compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.4.x.nix { }; 591 + }; 592 + ghc94 = packages.ghc948; 562 593 ghc962 = callPackage ../development/haskell-modules { 563 594 buildHaskellPackages = bh.packages.ghc962; 564 595 ghc = bh.compiler.ghc962;