Add better support for armv7a cross compilation

builder/comp-builder.nix

@@ -206,7 +206,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

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 (stdenv.targetPlatform.isMusl && builtins.compareVersions ghc.version "9.9" >0) ''
  ln -s $wrappedGhc/bin/${ghcCommand}-iserv $wrappedGhc/bin/ghc-iserv
  ln -s $wrappedGhc/bin/${ghcCommand}-iserv-prof $wrappedGhc/bin/ghc-iserv-prof
  ''

ci.nix

@@ -64,6 +64,7 @@
  nixpkgs.lib.optionalAttrs (nixpkgsName == "R2405") {
  ghc96 = false;
  ghc98 = false;
+ ghc910 = true;
  } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {
  ghc810 = true;
  ghc92 = false;
@@ -81,30 +82,32 @@
  let lib = nixpkgs.lib;
  in lib.optionalAttrs (nixpkgsName == "unstable"
  && (__match ".*llvm" compiler-nix-name == null)
- && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948"])
- || (system == "aarch64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948"])
- || (system == "x86_64-darwin" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948" "ghc966" "ghc982"])
- || (system == "aarch64-darwin" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948" "ghc966" "ghc982"])
+ && ((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"])
+ || (system == "aarch64-darwin" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948" "ghc966" "ghc982"])
  )) {
  inherit (lib.systems.examples) ghcjs;
  } // lib.optionalAttrs (
  (__match ".*llvm" compiler-nix-name == null)
- && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc91120240918"]) # Including GHC HEAD here because the patches for rts/RtsSymbols.c no longer apply and mingwW64 GHC build fails without them
+ && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc91120240918"]) # Including GHC HEAD here because the patches for rts/RtsSymbols.c no longer apply and mingwW64 GHC build fails without them
  || (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"
  && (__match ".*llvm" compiler-nix-name == null)
- && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc8107" "ghc902" "ghc928" "ghc948"])
+ && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc8107" "ghc902" "ghc928" "ghc948"])
  || (system == "x86_64-darwin" && builtins.elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity
  inherit (lib.systems.examples) ucrt64;
- } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948"]) {
+ } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948"]) {
  # 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"]) {
+ inherit (lib.systems.examples) musl32 musl64 aarch64-multiplatform;
+ } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && !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 ["ghc884" "ghc8107" "ghc902"]) {
+ } // lib.optionalAttrs (system == "aarch64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc8107" "ghc902"]) {
  inherit (lib.systems.examples) aarch64-multiplatform-musl;
  };
  isDisabled = d: d.meta.disabled or false;

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
@@ -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,6 +184,8 @@ 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
@@ -216,7 +219,10 @@ 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 ]
@@ -244,7 +250,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
@@ -339,7 +345,10 @@ 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'"
  # For GHC versions in the 9.x range that don't support the +native_bignum flavour transformer yet
  + lib.optionalString ((enableNativeBignum && !hadrianHasNativeBignumFlavour))
  " --bignum=native"
@@ -452,7 +461,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..."
@@ -527,7 +539,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
@@ -721,7 +733,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'
@@ -811,7 +823,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 && !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'

flake.nix

@@ -91,7 +91,7 @@
  callFlake = import flake-compat;
 
  ifdLevel = 3;
- runningHydraEvalTest = false;
+ runningHydraEvalTest = true;
  compiler = "ghc928";
  config = import ./config.nix;
 

lib/call-cabal-project-to-nix.nix

@@ -342,8 +342,14 @@ let
  echo ',("target arch","${
  if pkgs.stdenv.targetPlatform.isx86_64
  then "ArchX86_64"
+ else if pkgs.stdenv.targetPlatform.isx86
+ then "ArchX86"
+ else if pkgs.stdenv.targetPlatform.isRiscV64
+ then "ArchRISCV64"
  else if pkgs.stdenv.targetPlatform.isAarch64
  then "ArchAArch64"
+ else if pkgs.stdenv.targetPlatform.isAarch32
+ then "ArchAArch32"
  else if pkgs.stdenv.targetPlatform.isJavaScript
  then "ArchJavaScript"
  else throw "Unknown target arch ${pkgs.stdenv.targetPlatform.config}"
@@ -689,8 +695,8 @@ let
  cabal.project.freeze
  chmod +w cabal.project.freeze
  ''}
- export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt
- export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt
+ export SSL_CERT_FILE=${evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt
+ export GIT_SSL_CAINFO=${evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt
 
  export CABAL_DIR=${
  # This creates `.cabal` directory that is as it would have

lib/default.nix

@@ -256,9 +256,9 @@ in {
  isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform
  && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && stdenv.hostPlatform.linuxArch == stdenv.targetPlatform.linuxArch);
  # Native musl build-host-target combo
- isNativeMusl = stdenv.hostPlatform.isMusl
- && stdenv.buildPlatform == stdenv.hostPlatform
- && stdenv.hostPlatform == stdenv.targetPlatform;
+ isNativeMusl = stdenv.targetPlatform.isMusl
+ && stdenv.buildPlatform.linuxArch == stdenv.hostPlatform.linuxArch
+ && stdenv.hostPlatform.linuxArch == stdenv.targetPlatform.linuxArch;
 
  # Takes a version number, module or list of modules (for cabalProject)
  # and converts it to an list of project modules. This allows
@@ -593,6 +593,8 @@ in {
  then "arm"
  else if hostPlatform.isAarch64
  then "aarch64"
+ else if hostPlatform.isi686
+ then "i386"
  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

overlays/android.nix

@@ -11,18 +11,31 @@ _final: prev: prev.lib.optionalAttrs prev.stdenv.hostPlatform.isAndroid ({
  '';
  # my current thinking is that this is due to the android toolchain using r23, api30.
  });
- libffi = prev.libffi.overrideAttrs (_: {
+ libffi = prev.libffi.overrideAttrs ( old: {
  dontDisableStatic = true;
+ configureFlags = old.configureFlags ++ [ "--disable-shared" ];
 
  hardeningDisable = [ "fortify" "stackprotector" "format" ];
+ } // prev.lib.optionalAttrs (prev.stdenv.hostPlatform.isAarch32 || prev.stdenv.hostPlatform.isAarch64) {
  # see libiconv. We want to target a lower minsdk
  postConfigure = ''
- echo "#undef HAVE_MEMFD_CREATE" >> aarch64-unknown-linux-android/fficonfig.h
+ echo "#undef HAVE_MEMFD_CREATE" >> ${prev.stdenv.hostPlatform.config}/fficonfig.h
  '';
  });
- gmp6 = (prev.gmp6.override { withStatic = true; }).overrideAttrs(_: {
+ gmp6 = (prev.gmp6.override { withStatic = true; }).overrideAttrs(old: {
  hardeningDisable = [ "fortify" "stackprotector" "format" ];
+ configureFlags = old.configureFlags ++ [ "--disable-shared" ];
  });
+ zlib = prev.zlib.override { shared = false; static = true; };
+ # kernel tls (ktls) doesn't work with the android kernel. And will complain
+ # about lots of implicitly declared functions and undeclared identifiers,
+ # because the android (linux) kernel doesn't expose those.
+ openssl = prev.openssl.override { static = true; enableKTLS = false; };
+
 }) // prev.lib.optionalAttrs (prev.stdenv.targetPlatform.isAndroid && (!prev.stdenv.hostPlatform.useAndroidPrebuilt)) ({
- bionic = prev.bionic.override { enableStatic = true; };
+ # we still need the shared libraries to link against on the platform. GHC
+ # has been neutered to not even try loading shared libs and will use dynamic ones.
+ # We also link iserv against the static libs, so that we have a fully static
+ # android (bionic/linux) iserv we can execute on glibc/linux.
+ bionic = prev.bionic.override { enableStatic = true; enableShared = true; };
 })