Add better support for armv7a cross compilation

build.nix

@@ -57,10 +57,15 @@ in rec {
         inherit evalPackages;
         src = pkgs.haskell-nix.sources."hls-2.2";
       };
-    } // pkgs.lib.optionalAttrs (ghcFromTo "9.0" "9.8.3" || ghcFromTo "9.10" "9.11") {
-      "hls-29" = tool compiler-nix-name "haskell-language-server" {
+    } // pkgs.lib.optionalAttrs (ghcFromTo "9.0" "9.11") {
+      "hls" = tool compiler-nix-name "haskell-language-server" {
         inherit evalPackages;
-        src = pkgs.haskell-nix.sources."hls-2.9";
+        src = pkgs.haskell-nix.sources.hls;
+        cabalProjectLocal = ''
+          if impl(ghc >=9.6.7) && impl(ghc <9.7) || impl(ghc >=9.8.3)
+            constraints: ghc-lib-parser >=9.8.4
+            allow-older: ghc-lib-parser:filepath
+        '';
       };
     })
   );

builder/comp-builder.nix

@@ -209,7 +209,15 @@ let
       (enableFeature enableShared "shared")
       (enableFeature enableExecutableDynamic "executable-dynamic")
       (enableFeature doCoverage "coverage")
-      (enableFeature (enableLibraryForGhci && !stdenv.hostPlatform.isGhcjs) "library-for-ghci")
+      # For Android (or really anything that uses lld), -r will silently drop
+      # "lazy" symbols. Those are leaf symbols with no referenes. This however
+      # does not work when loading the objects into the linker, because then we
+      # occationally miss symbols when subsequent libraries depending on the one
+      # that dropped the symbol are loaded.  bfd and lld support --whole-archive
+      # lld -r --whole-archive ... will _not_ drop lazy symbols. However the
+      # --whole-archive flag needs to come _before_ the objects, it's applied in
+      # sequence. The proper fix is thusly to add --while-archive to Cabal.
+      (enableFeature (enableLibraryForGhci && !stdenv.hostPlatform.isGhcjs && !stdenv.hostPlatform.isAndroid) "library-for-ghci")
     ] ++ lib.optionals (stdenv.hostPlatform.isMusl && (haskellLib.isExecutableType componentId)) [
       # These flags will make sure the resulting executable is statically linked.
       # If it uses other libraries it may be necessary for to add more
@@ -377,8 +385,8 @@ let
         inherit (package.identifier) version;
         nativeBuildInputs = [shellWrappers.drv] ++ attrs.nativeBuildInputs;
       });
-      profiled = self (drvArgs // { enableLibraryProfiling = true; });
-      dwarf = self (drvArgs // { enableDWARF = true; });
+      profiled = lib.makeOverridable self (drvArgs // { enableLibraryProfiling = true; });
+      dwarf = lib.makeOverridable self (drvArgs // { enableDWARF = true; });
     } // lib.optionalAttrs (haskellLib.isLibrary componentId || haskellLib.isTest componentId) ({
         inherit haddock;
         inherit (haddock) haddockDir; # This is null if `doHaddock = false`

builder/default.nix

@@ -68,7 +68,7 @@ let
     let
       haskellPackages = {
         # For musl we can use haddock from the buildGHC
-        ghc = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl
+        ghc = if stdenv.targetPlatform.isMusl
           then ghc.buildGHC
           else ghc;
         inherit packages hoogle;

builder/ghc-for-component-wrapper.nix

@@ -23,7 +23,7 @@ let
   libDir         = "$wrappedGhc/${configFiles.libDir}";
   docDir         = "$wrappedGhc/share/doc/ghc/html";
   # For musl we can use haddock from the buildGHC
-  haddock        = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl
+  haddock        = if stdenv.targetPlatform.isMusl
     then ghc.buildGHC
     else ghc;
 
@@ -125,7 +125,7 @@ let
     done
 
   ''
-  + lib.optionalString (stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl && builtins.compareVersions ghc.version "9.9" >0) ''
+  + lib.optionalString (haskellLib.isNativeMusl && builtins.compareVersions ghc.version "9.9" >0) ''
      ln -s $wrappedGhc/bin/${targetPrefix}unlit $wrappedGhc/bin/unlit
      ln -s $wrappedGhc/bin/${ghcCommand}-iserv $wrappedGhc/bin/ghc-iserv
      ln -s $wrappedGhc/bin/${ghcCommand}-iserv-prof $wrappedGhc/bin/ghc-iserv-prof

ci.nix

@@ -58,13 +58,14 @@
       # from here (so that is no longer cached) also remove ./materialized/ghcXXX.
       # Update supported-ghc-versions.md to reflect any changes made here.
       nixpkgs.lib.optionalAttrs (nixpkgsName == "R2411") {
-        ghc96 = false;
-        ghc98 = false;
-        ghc910 = false;
-        ghc912 = true;
-      } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {
         ghc96 = true;
         ghc98 = true;
+        ghc910 = true;
+        ghc9121 = true;
+      } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {
+        ghc96 = false;
+        ghc96X = true;
+        ghc98 = true;
         ghc98llvm = false;
         ghc910 = true;
         ghc910llvm = true;
@@ -80,13 +81,13 @@
       && (__match ".*llvm" compiler-nix-name == null)
       && ((system == "x86_64-linux"  && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948"])
        || (system == "aarch64-linux" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948"])
-       || (system == "x86_64-darwin" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948" "ghc966" "ghc982" "ghc983" "ghc984"])
-       || (system == "aarch64-darwin" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948" "ghc966" "ghc982" "ghc983" "ghc984"])
+       || (system == "x86_64-darwin" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948" "ghc966" "ghc96720250227" "ghc982" "ghc983" "ghc984"])
+       || (system == "aarch64-darwin" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948" "ghc966" "ghc96720250227" "ghc982" "ghc983" "ghc984"])
        )) {
     inherit (lib.systems.examples) ghcjs;
-  } // lib.optionalAttrs (
-         (__match ".*llvm" compiler-nix-name == null)
-      && ((system == "x86_64-linux"  && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc966"]) # Not sure why GHC 9.6.6 TH code now wants `log1pf`
+  } // lib.optionalAttrs (nixpkgsName == "unstable"
+      && (__match ".*llvm" compiler-nix-name == null)
+      && ((system == "x86_64-linux"  && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc966" "ghc96720250227"]) # Not sure why GHC 9.6.6 TH code now wants `log1pf`
        || (system == "x86_64-darwin" && builtins.elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity
     inherit (lib.systems.examples) mingwW64;
   } // lib.optionalAttrs (nixpkgsName == "unstable"
@@ -98,7 +99,12 @@
     # 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" && builtins.elem compiler-nix-name ["ghc927" "ghc928"]) {
+  } // lib.optionalAttrs (__match ".*llvm" compiler-nix-name == null && system == "x86_64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948"]) {
+    # Out llvm versions of GHC seem to break for musl32
+    inherit (lib.systems.examples) musl32;
+  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "R2411" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948"]) {
+    inherit (lib.systems.examples) aarch64-android-prebuilt armv7a-android-prebuilt;
+  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc8107" "ghc902"]) {
     # 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" && !builtins.elem compiler-nix-name ["ghc8107" "ghc902"]) {

compiler/ghc/default.nix

@@ -45,9 +45,9 @@ let self =
 
 , enableDWARF ? false
 
-, enableTerminfo ?
+, enableTerminfo ? !stdenv.targetPlatform.isAndroid &&
     # Terminfo does not work on older ghc cross arm and windows compilers
-     (!haskell-nix.haskellLib.isCrossTarget || !(stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) || builtins.compareVersions ghc-version "8.10" >= 0)
+     (!haskell-nix.haskellLib.isCrossTarget || !(stdenv.targetPlatform.isAarch32 || stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) || builtins.compareVersions ghc-version "8.10" >= 0)
 
 , # Wheter to build in NUMA support
   enableNUMA ? true
@@ -62,7 +62,7 @@ let self =
 
 , # Whether to disable the large address space allocator
   # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
+  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isAndroid
 
 , useLdGold ?
     # might be better check to see if cc is clang/llvm?
@@ -169,8 +169,9 @@ let
     WITH_TERMINFO=NO
   ''
   # musl doesn't have a system-linker. Only on x86, and on x86 we need it, as
-  # our elf linker for x86_64 is broken.
-  + lib.optionalString (targetPlatform.isAndroid || (targetPlatform.isMusl && !targetPlatform.isx86)) ''
+  # our elf linker for x86_64 is broken. The i686 one seems also to not exist.
+  # So it's really _just_ x86_64.
+  + lib.optionalString (targetPlatform.isAndroid || (targetPlatform.isMusl && !targetPlatform.isx86_64)) ''
     compiler_CONFIGURE_OPTS += --flags=-dynamic-system-linker
   ''
   # While split sections are now enabled by default in ghc 8.8 for windows,
@@ -183,12 +184,14 @@ let
     SplitSections = NO
   '' + lib.optionalString (!enableLibraryProfiling) ''
     BUILD_PROF_LIBS = NO
+  '' + lib.optionalString (disableLargeAddressSpace) ''
+    libraries/base_CONFIGURE_OPTS += --configure-option=--with-libcharset=no
   '';
 
   # `--with` flags for libraries needed for RTS linker
   configureFlags = [
         "--datadir=$doc/share/doc/ghc"
-    ] ++ lib.optionals (!targetPlatform.isGhcjs) ["--with-curses-includes=${targetPackages.ncurses.dev}/include" "--with-curses-libraries=${targetPackages.ncurses.out}/lib"
+    ] ++ lib.optionals (!targetPlatform.isGhcjs && !targetPlatform.isAndroid) ["--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"
@@ -216,23 +219,24 @@ let
         # https://gitlab.haskell.org/ghc/ghc/-/issues/23188
         # https://github.com/haskell/cabal/issues/8882
         "fp_cv_prog_ar_supports_dash_l=no"
-    ] ++ lib.optional (targetPlatform.isGhcjs) "--target=javascript-unknown-ghcjs"; # TODO use configurePlatforms once tripple is updated in nixpkgs
+    ] ++ lib.optionals (targetPlatform.isDarwin) [
+        "--without-libcharset"
+    ] ++ 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 && !targetPlatform.isGhcjs) [ targetPackages.ncurses targetPackages.ncurses.dev ]
+  libDeps = platform: lib.optional (enableTerminfo && !targetPlatform.isGhcjs && !targetPlatform.isAndroid) [ 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 targetPlatform.isGhcjs
       then [ buildPackages.emscripten ]
     else if hostPlatform == buildPlatform
-      then [ targetPackages.stdenv.cc ] ++ lib.optionals useLLVM [llvmPackages.llvm llvmPackages.clang]
+      then [ targetPackages.stdenv.cc ] ++ lib.optionals useLLVM ([llvmPackages.llvm] ++ lib.optional (!targetPlatform.useAndroidPrebuilt) llvmPackages.clang)
     else assert targetPlatform == hostPlatform; # build != host == target
       [ stdenv.cc ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
 
@@ -244,7 +248,7 @@ let
   # 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);
+  installStage1 = useHadrian && (with haskell-nix.haskellLib; isCrossTarget || isNativeMusl);
 
   hadrian =
     let
@@ -345,7 +349,14 @@ let
         " '*.ghc.cabal.configure.opts += --flags=-dynamic-system-linker'"
       # The following is required if we build on aarch64-darwin for aarch64-iOS. Otherwise older
       # iPhones/iPads/... won't understand the compiled code, as the compiler will emit LDSETALH
-      # + lib.optionalString (targetPlatform.???) "'*.rts.ghc.c.opts += -optc-mcpu=apple-a7 -optc-march=armv8-a+norcpc'"
+      # FIXME: we should have iOS as an argument to this derivation, and then make this, as well as
+      #        disableLargeAddress space conditional on iOS = true.
+      + lib.optionalString (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64)
+        " '*.*.ghc.c.opts += -optc-mcpu=apple-a7 -optc-march=armv8-a+norcpc'"
+      + lib.optionalString (targetPlatform.isAndroid && targetPlatform.isAarch32)
+        " 'stage1.*.ghc.c.opts += -optc-march=armv7-a -optc-mfloat-abi=softfp -optc-mfpu=vfpv3-d16'"
+      + lib.optionalString (targetPlatform.isAndroid && targetPlatform.isAarch64)
+        " 'stage1.*.ghc.c.opts += -optc-march=armv8-a'"
       # For GHC versions in the 9.x range that don't support the +native_bignum flavour transformer yet
       + lib.optionalString ((enableNativeBignum && !hadrianHasNativeBignumFlavour))
         " --bignum=native"
@@ -462,7 +473,10 @@ stdenv.mkDerivation (rec {
         export NIX_LDFLAGS+=" -rpath $out/lib/${targetPrefix}ghc-${ghc-version}"
     '' + lib.optionalString stdenv.isDarwin ''
         export NIX_LDFLAGS+=" -no_dtrace_dof"
-    '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
+    '' +
+    # we really want "+armv7-a,+soft-float,+neon" as features, but llvm will
+    # fail with those :facepalm:
+    lib.optionalString targetPlatform.useAndroidPrebuilt ''
         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
     '' + lib.optionalString targetPlatform.isMusl ''
         echo "patching llvm-targets for musl targets..."
@@ -537,7 +551,7 @@ stdenv.mkDerivation (rec {
                    ++ lib.optional stdenv.targetPlatform.isMusl "pie"
                    ++ lib.optional enableDWARF "fortify";
 
-  postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux) ''
+  postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux && !targetPlatform.isAarch32 && !targetPlatform.isAndroid) ''
     # Patch rts.conf to ensure libnuma can be found
 
     for file in $(find "$out/lib" -name "rts*.conf"); do
@@ -731,7 +745,7 @@ stdenv.mkDerivation (rec {
           --replace 'dynamic-library-dirs:' 'dynamic-library-dirs: ${libcxx}/lib'
         find . -name 'system*.conf*'
         cat mk/system-cxx-std-lib-1.0.conf
-      '' + lib.optionalString (installStage1 && stdenv.targetPlatform.isMusl) ''
+      '' + lib.optionalString (installStage1 && haskell-nix.haskellLib.isNativeMusl) ''
         substituteInPlace hadrian/cfg/system.config \
           --replace 'cross-compiling       = YES' \
                     'cross-compiling       = NO'
@@ -781,7 +795,7 @@ stdenv.mkDerivation (rec {
   dontStrip = true;
   dontPatchELF = true;
   noAuditTmpdir = true;
-} // lib.optionalAttrs (stdenv.buildPlatform.isDarwin || stdenv.targetPlatform.isWindows) {
+} // {
   # ghc install on macOS wants to run `xattr -r -c`
   # The macOS version fails because it wants python 2.
   # The nix version of xattr does not support those args.
@@ -821,12 +835,13 @@ stdenv.mkDerivation (rec {
       --replace 'dynamic-library-dirs:' 'dynamic-library-dirs: ${libcxx}/lib'
     find . -name 'system*.conf*'
     cat mk/system-cxx-std-lib-1.0.conf
-  '' + lib.optionalString (installStage1 && !haskell-nix.haskellLib.isCrossTarget && stdenv.targetPlatform.isMusl) ''
+  '' + lib.optionalString (installStage1 && haskell-nix.haskellLib.isNativeMusl) ''
     substituteInPlace hadrian/cfg/system.config \
       --replace 'cross-compiling       = YES' \
                 'cross-compiling       = NO'
   '';
   buildPhase = ''
+    runHook preBuild
     ${hadrian}/bin/hadrian ${hadrianArgs}
   '' + lib.optionalString (installStage1 && !stdenv.targetPlatform.isGhcjs && builtins.compareVersions ghc-version "9.8" < 0) ''
     ${hadrian}/bin/hadrian ${hadrianArgs} stage1:lib:libiserv
@@ -841,6 +856,8 @@ stdenv.mkDerivation (rec {
       mv $exe ${targetPrefix}$exe
     done
     popd
+  '' + ''
+    runHook postBuild
   '';
 
   # Hadrian's installation only works for native compilers, and is broken for cross compilers.