Merge branch 'master' of github.com:input-output-hk/haskell.nix into circuithub

Author: ocharles

builder/comp-builder.nix

@@ -165,16 +165,13 @@ let
     ) ++ [ "$(cat $configFiles/configure-flags)"
     ] ++ commonConfigureFlags);
 
-  # From nixpkgs 20.09, the pkg-config exe has a prefix matching the ghc one
-  pkgConfigHasPrefix = builtins.compareVersions lib.version "20.09pre" >= 0;
-
   commonConfigureFlags = ([
       # GHC
       "--with-ghc=${ghc.targetPrefix}ghc"
       "--with-ghc-pkg=${ghc.targetPrefix}ghc-pkg"
       "--with-hsc2hs=${ghc.targetPrefix}hsc2hs"
-    ] ++ lib.optional (pkgConfigHasPrefix && pkgconfig != [])
-      "--with-pkg-config=${ghc.targetPrefix}pkg-config"
+    ] ++ lib.optional (pkgconfig != [])
+      "--with-pkg-config=${buildPackages.cabalPkgConfigWrapper.targetPrefix}pkg-config"
       ++ lib.optionals (stdenv.hasCC or (stdenv.cc != null))
     ( # CC
       [ "--with-gcc=${stdenv.cc.targetPrefix}cc"

builder/ghc-for-component-wrapper.nix

@@ -39,7 +39,11 @@ let
   ''
   # ... but retain the lib/ghc/bin directory. This contains `unlit' and friends.
   + ''
-    ln -s $unwrappedGhc/lib/${ghcCommand}-${ghc.version}/bin ${libDir}
+    if [ -d $unwrappedGhc/lib/${ghcCommand}-${ghc.version}/bin ]; then
+      ln -s $unwrappedGhc/lib/${ghcCommand}-${ghc.version}/bin ${libDir}
+    else
+      ln -s $unwrappedGhc/lib/bin ${libDir}
+    fi
   ''
   # ... and the ghcjs shim's if they are available ...
   + ''

ci.nix

@@ -58,16 +58,15 @@
         ghc902 = false;
         ghc927 = true;
         ghc944 = true;
-        ghc96020230302 = true;
         ghc961 = true;
       }));
   crossSystems = nixpkgsName: nixpkgs: compiler-nix-name:
     # We need to use the actual nixpkgs version we're working with here, since the values
     # of 'lib.systems.examples' are not understood between all versions
     let lib = nixpkgs.lib;
     in lib.optionalAttrs (nixpkgsName == "unstable"
-      && ((system == "x86_64-linux"  && __elem compiler-nix-name ["ghc865" "ghc884" "ghc8107"])
-       || (system == "x86_64-darwin" && __elem compiler-nix-name ["ghc8107"]))) {
+      && ((system == "x86_64-linux"  && __elem compiler-nix-name ["ghc865" "ghc884" "ghc8107" "ghc961"])
+       || (system == "x86_64-darwin" && __elem compiler-nix-name ["ghc8107" "ghc961"]))) {
     inherit (lib.systems.examples) ghcjs;
   } // lib.optionalAttrs (nixpkgsName == "unstable"
       && ((system == "x86_64-linux"  && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc926" "ghc927" "ghc944" "ghc961"])

compiler/ghc/default.nix

@@ -20,7 +20,8 @@ let self =
 , # GHC can be built with system libffi or a bundled one.
   libffi ? null
 
-, useLLVM ? !stdenv.targetPlatform.isx86
+, # we don't need LLVM for x86, aarch64, or ghcjs
+  useLLVM ? with stdenv.targetPlatform; !(isx86 || isAarch64 || isGhcjs)
 , # LLVM is conceptually a run-time-only dependency, but for
   # non-x86, we need LLVM to bootstrap later stages, so it becomes a
   # build-time dependency too.
@@ -121,8 +122,10 @@ let
 
   # TODO(@Ericson2314) Make unconditional
   targetPrefix = lib.optionalString
-    (targetPlatform != hostPlatform)
-    "${targetPlatform.config}-";
+    (targetPlatform != hostPlatform) (
+      if useHadrian && targetPlatform.isGhcjs
+        then "javascript-unknown-ghcjs-"
+        else "${targetPlatform.config}-");
 
   buildMK = ''
     BuildFlavour = ${ghcFlavour}
@@ -177,13 +180,13 @@ let
   # `--with` flags for libraries needed for RTS linker
   configureFlags = [
         "--datadir=$doc/share/doc/ghc"
-        "--with-curses-includes=${targetPackages.ncurses.dev}/include" "--with-curses-libraries=${targetPackages.ncurses.out}/lib"
-    ] ++ lib.optionals (targetLibffi != null) ["--with-system-libffi" "--with-ffi-includes=${targetLibffi.dev}/include" "--with-ffi-libraries=${targetLibffi.out}/lib"
-    ] ++ lib.optionals (!enableIntegerSimple) [
+    ] ++ lib.optionals (!targetPlatform.isGhcjs) ["--with-curses-includes=${targetPackages.ncurses.dev}/include" "--with-curses-libraries=${targetPackages.ncurses.out}/lib"
+    ] ++ lib.optionals (targetLibffi != null && !targetPlatform.isGhcjs) ["--with-system-libffi" "--with-ffi-includes=${targetLibffi.dev}/include" "--with-ffi-libraries=${targetLibffi.out}/lib"
+    ] ++ lib.optionals (!enableIntegerSimple && !targetPlatform.isGhcjs) [
         "--with-gmp-includes=${targetGmp.dev}/include" "--with-gmp-libraries=${targetGmp.out}/lib"
     ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
         "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"
-    ] ++ lib.optionals (targetPlatform != hostPlatform) [
+    ] ++ lib.optionals (targetPlatform != hostPlatform && !targetPlatform.isGhcjs) [
         "--with-iconv-includes=${targetIconv}/include" "--with-iconv-libraries=${targetIconv}/lib"
     ] ++ lib.optionals (targetPlatform != hostPlatform) [
         "--enable-bootstrap-with-devel-snapshot"
@@ -198,29 +201,35 @@ let
         "--enable-dwarf-unwind"
         "--with-libdw-includes=${lib.getDev elfutils}/include"
         "--with-libdw-libraries=${lib.getLib elfutils}/lib"
-    ];
+    ] ++ lib.optional (targetPlatform.isGhcjs) "--target=javascript-unknown-ghcjs"; # TODO use configurePlatforms once tripple is updated in nixpkgs
 
   # Splicer will pull out correct variations
-  libDeps = platform: lib.optional enableTerminfo [ targetPackages.ncurses targetPackages.ncurses.dev ]
-    ++ [targetLibffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
+  libDeps = platform: lib.optional (enableTerminfo && !targetPlatform.isGhcjs) [ targetPackages.ncurses targetPackages.ncurses.dev ]
+    ++ lib.optional (!targetPlatform.isGhcjs) targetLibffi
+    ++ lib.optional (!enableIntegerSimple && !targetPlatform.isGhcjs) gmp
     ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv
     ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl
     # Even with terminfo disabled some older ghc cross arm and windows compilers do not build unless `ncurses` is found and they seem to want the buildPlatform version
     ++ lib.optional (!enableTerminfo && haskell-nix.haskellLib.isCrossTarget && (stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) && builtins.compareVersions ghc-version "8.10" < 0) ncurses.dev
     ++ lib.optional enableDWARF (lib.getLib elfutils);
 
   toolsForTarget =
-    if hostPlatform == buildPlatform then
-      [ targetPackages.stdenv.cc ] ++ lib.optional useLLVM llvmPackages.llvm
+    if targetPlatform.isGhcjs
+      then [ buildPackages.emscripten ]
+    else if hostPlatform == buildPlatform
+      then [ targetPackages.stdenv.cc ] ++ lib.optional useLLVM llvmPackages.llvm
     else assert targetPlatform == hostPlatform; # build != host == target
       [ stdenv.cc ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
 
   targetCC = builtins.head toolsForTarget;
 
   useHadrian = builtins.compareVersions ghc-version "9.4" >= 0;
   # Indicates if we are installing by copying the hadrian stage1 output
-  installStage1 = useHadrian && (haskell-nix.haskellLib.isCrossTarget || targetPlatform.isMusl);
+  # I think we want to _always_ just install stage1. For now let's do this
+  # for musl only; but I'd like to stay far away from the unnecessary
+  # bindist logic as we can. It's slow, and buggy, and doesn't provide any
+  # value for us.
+  installStage1 = useHadrian && (haskell-nix.haskellLib.isCrossTarget || stdenv.targetPlatform.isMusl);
 
   inherit ((buildPackages.haskell-nix.cabalProject {
       compiler-nix-name = "ghc8107";
@@ -248,9 +257,11 @@ let
   # For build flavours and flavour transformers
   # see https://gitlab.haskell.org/ghc/ghc/blob/master/hadrian/doc/flavours.md
   hadrianArgs = "--flavour=${
-        "default"
+        (if targetPlatform.isGhcjs then "quick" else "default")
           + lib.optionalString (!enableShared) "+no_dynamic_ghc"
           + lib.optionalString useLLVM "+llvm"
+          + lib.optionalString enableDWARF "+debug_info"
+          + lib.optionalString targetPlatform.isGhcjs "+native_bignum+no_profiled_libs"
       } --docs=no-sphinx -j --verbose";
 
   # When installation is done by copying the stage1 output the directory layout
@@ -310,10 +321,15 @@ stdenv.mkDerivation (rec {
         for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
         export "''${env#TARGET_}=''${!env}"
         done
+    '' + lib.optionalString (targetPlatform.isGhcjs) ''
+        export CC="${targetCC}/bin/emcc"
+        export CXX="${targetCC}/bin/em++"
+        export LD="${targetCC}/bin/emcc"
+        export EM_CACHE=$(mktemp -d)
     ''
     # GHC is a bit confused on its cross terminology, as these would normally be
     # the *host* tools.
-    + ''
+    + lib.optionalString (!targetPlatform.isGhcjs) (''
         export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
         export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
     ''
@@ -329,7 +345,7 @@ stdenv.mkDerivation (rec {
     '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") ''
         export OTOOL="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}otool"
         export INSTALL_NAME_TOOL="${bintoolsFor.install_name_tool}/bin/${bintoolsFor.install_name_tool.targetPrefix}install_name_tool"
-    '' + lib.optionalString (targetPlatform == hostPlatform && useLdGold) 
+    '') + lib.optionalString (targetPlatform == hostPlatform && useLdGold) 
     # set LD explicitly if we want gold even if we aren't cross compiling
     ''
         export LD="${targetCC.bintools}/bin/ld.gold"
@@ -376,7 +392,7 @@ stdenv.mkDerivation (rec {
         ./boot
     '';
 
-  configurePlatforms = [ "build" "host" "target" ];
+  configurePlatforms = [ "build" "host" ] ++ lib.optional (!targetPlatform.isGhcjs) "target";
 
   enableParallelBuilding = true;
   postPatch = "patchShebangs .";
@@ -399,8 +415,8 @@ stdenv.mkDerivation (rec {
 
   buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
 
-  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
+  depsTargetTarget = lib.optionals (!targetPlatform.isGhcjs) (map lib.getDev (libDeps targetPlatform));
+  depsTargetTargetPropagated = lib.optionals (!targetPlatform.isGhcjs) (map (lib.getOutput "out") (libDeps targetPlatform));
 
   # required, because otherwise all symbols from HSffi.o are stripped, and
   # that in turn causes GHCi to abort
@@ -438,7 +454,7 @@ stdenv.mkDerivation (rec {
       # The ghcprog fixup is for musl (where runhaskell script just needs to point to the correct
       # ghc program to work).
       sed -i \
-        -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' \
+        -e '2i export PATH="$PATH:${lib.makeBinPath (lib.optionals (!targetPlatform.isGhcjs) [ targetPackages.stdenv.cc.bintools coreutils ])}"' \
         -e 's/ghcprog="ghc-/ghcprog="${targetPrefix}ghc-/' \
         $i
     done
@@ -586,6 +602,10 @@ stdenv.mkDerivation (rec {
           --replace 'dynamic-library-dirs:' 'dynamic-library-dirs: ${libcxx}/lib ${libcxxabi}/lib'
         find . -name 'system*.conf*'
         cat mk/system-cxx-std-lib-1.0.conf
+      '' + lib.optionalString (installStage1 && stdenv.targetPlatform.isMusl) ''
+        substituteInPlace hadrian/cfg/system.config \
+          --replace 'cross-compiling       = YES' \
+                    'cross-compiling       = NO'
       '';
     });
 
@@ -651,13 +671,24 @@ stdenv.mkDerivation (rec {
       --replace 'dynamic-library-dirs:' 'dynamic-library-dirs: ${libcxx}/lib ${libcxxabi}/lib'
     find . -name 'system*.conf*'
     cat mk/system-cxx-std-lib-1.0.conf
+  '' + lib.optionalString (installStage1 && stdenv.targetPlatform.isMusl) ''
+    substituteInPlace hadrian/cfg/system.config \
+      --replace 'cross-compiling       = YES' \
+                'cross-compiling       = NO'
   '';
   buildPhase = ''
     ${hadrian}/bin/hadrian ${hadrianArgs}
-  '' + lib.optionalString installStage1 ''
+  '' + lib.optionalString (installStage1 && !stdenv.targetPlatform.isGhcjs) ''
     ${hadrian}/bin/hadrian ${hadrianArgs} stage1:lib:libiserv
   '' + lib.optionalString targetPlatform.isMusl ''
     ${hadrian}/bin/hadrian ${hadrianArgs} stage1:lib:terminfo
+  '' + lib.optionalString (installStage1 && !haskell-nix.haskellLib.isCrossTarget) ''
+    ${hadrian}/bin/hadrian ${hadrianArgs} stage2:exe:iserv
+    pushd _build/stage1/bin
+    for exe in *; do
+      mv $exe ${targetPrefix}$exe
+    done
+    popd
   '';
 
   # Hadrian's installation only works for native compilers, and is broken for cross compilers.

compiler/windows/include/windows.h

@@ -7,6 +7,8 @@
 
 typedef unsigned long DWORD;
 typedef void * PVOID;
+typedef PVOID HANDLE;
+typedef void CRITICAL_SECTION;
 
 typedef struct _RTL_CONDITION_VARIABLE { PVOID Ptr; } RTL_CONDITION_VARIABLE;
 typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE;

flake.lock

@@ -10,7 +10,7 @@
     nixpkgs-2211 = { url = "github:NixOS/nixpkgs/nixpkgs-22.11-darwin"; };
     nixpkgs-unstable = { url = "github:NixOS/nixpkgs/nixpkgs-unstable"; };
     flake-compat = { url = "github:input-output-hk/flake-compat/hkm/gitlab-fix"; flake = false; };
-    flake-utils = { url = "github:numtide/flake-utils"; };
+    flake-utils = { url = "github:hamishmack/flake-utils/hkm/nested-hydraJobs"; };
     tullia = {
       url = "github:input-output-hk/tullia";
       inputs.nixpkgs.follows = "nixpkgs";