Support aarch64-multiplatform-musl (#1911)

Author: hamishmack

builder/comp-builder.nix

@@ -14,6 +14,7 @@ let self =
 
 , preUnpack ? component.preUnpack, postUnpack ? component.postUnpack
 , configureFlags ? component.configureFlags
+, prePatch ? component.prePatch, postPatch ? component.postPatch
 , preConfigure ? component.preConfigure, postConfigure ? component.postConfigure
 , setupBuildFlags ? component.setupBuildFlags
 , preBuild ? component.preBuild , postBuild ? component.postBuild
@@ -42,9 +43,6 @@ let self =
 
 , enableStatic ? component.enableStatic
 , enableShared ? ghc.enableShared && component.enableShared && !haskellLib.isCrossHost
-               # on x86 we'll use shared libraries, even with musl m(
-               # ghc's internal linker seems to be broken on x86.
-               && !(stdenv.hostPlatform.isMusl && !stdenv.hostPlatform.isx86)
 , enableDeadCodeElimination ? component.enableDeadCodeElimination
 , writeHieFiles ? component.writeHieFiles
 
@@ -289,7 +287,7 @@ let
             lib.optionalString (cabal-generator == "hpack") ''
               ${buildPackages.haskell-nix.internal-nix-tools}/bin/hpack
             ''
-        );
+        ) + lib.optionalString (prePatch != null) "\n${prePatch}";
     }
     # patches can (if they like) depend on the version of the package.
     // lib.optionalAttrs (patches != []) {
@@ -301,7 +299,7 @@ let
     }
     // haskellLib.optionalHooks {
       # These are hooks are needed to set up the source for building and running haddock
-      inherit preUnpack postUnpack preConfigure postConfigure;
+      inherit preUnpack postUnpack postPatch preConfigure postConfigure;
     }
     // lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc") {
       LOCALE_ARCHIVE = "${buildPackages.glibcLocales}/lib/locale/locale-archive";

ci.nix

@@ -79,6 +79,11 @@
     # Musl cross only works on linux
     # aarch64 cross only works on linux
     inherit (lib.systems.examples) musl64 aarch64-multiplatform;
+  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc927"]) {
+    # TODO fix this for the compilers we build with hadrian (ghc >=9.4)
+    inherit (lib.systems.examples) aarch64-multiplatform-musl;
+  } // lib.optionalAttrs (system == "aarch64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc927" "ghc944" "ghc961"]) {
+    inherit (lib.systems.examples) aarch64-multiplatform-musl;
   };
   isDisabled = d: d.meta.disabled or false;
 in

compiler/ghc/default.nix

@@ -231,8 +231,7 @@ let
   # value for us.
   installStage1 = useHadrian && (haskell-nix.haskellLib.isCrossTarget || stdenv.targetPlatform.isMusl);
 
-  inherit ((buildPackages.haskell-nix.cabalProject {
-      compiler-nix-name = "ghc8107";
+  hadrian = buildPackages.haskell-nix.tool "ghc8107" "hadrian" {
       compilerSelection = p: p.haskell.compiler;
       index-state = buildPackages.haskell-nix.internalHackageIndexState;
       # Verions of hadrian that comes with 9.6 depends on `time`
@@ -242,15 +241,23 @@ let
         else if builtins.compareVersions ghc-version "9.6" < 0
           then ../../materialized/ghc8107/hadrian-ghc94
         else ../../materialized/ghc8107/hadrian-ghc96;
+      modules = [{
+        # Apply the patches in a way that does not require using somethin
+        # like `srcOnly`. The problem with `pkgs.srcOnly` was that it had to run
+        # on a platform at eval time.
+        packages.hadrian.prePatch = ''
+          cd ..
+        '';
+        packages.hadrian.patches = ghc-patches;
+        packages.hadrian.postPatch = ''
+          cd hadrian
+        '';
+      }];        
       src = haskell-nix.haskellLib.cleanSourceWith {
-        src = buildPackages.srcOnly {
-          name = "hadrian";
-          inherit src;
-          patches = ghc-patches;
-        };
+        inherit src;
         subDir = "hadrian";
       };
-    }).hsPkgs.hadrian.components.exes) hadrian;
+    };
 
   # For a discription of hadrian command line args
   # see https://gitlab.haskell.org/ghc/ghc/blob/master/hadrian/README.md

lib/default.nix

@@ -573,4 +573,19 @@ in {
     inherit pkgs;
     inherit (pkgs.buildPackages.buildPackages) runCommand;
   };
+
+  # Here we try to figure out which qemu to use based on the host platform.
+  # This guess can be overridden by passing qemuSuffix
+  qemuByHostPlatform = hostPlatform:
+    # I'd prefer this was a dictionary lookup, with a fall through into abort,
+    # that would make this more readable I guess.  I think there is some similar
+    # mapping somewhere in haskell.nix
+    if hostPlatform.isAarch32
+    then "arm"
+    else if hostPlatform.isAarch64
+    then "aarch64"
+    else abort "Don't know which QEMU to use for hostPlatform ${hostPlatform.config}. Please provide qemuSuffix";
+
+  # How to run ldd when checking for static linking
+  lddForTests = "${pkgs.pkgsBuildBuild.glibc.bin}/bin/ldd";
 }